多线程编译

㈠ QT如何进行线程编译

在Qt中使用多线程，目前就我使用过的有两种，一是子类化QThread，重写run函数，在run函数里实现自己的代码，这一部分代码通常是比较耗时，或者干脆直接阻塞的。比如一个while循环，设置一个标志，判断循环结束。
这样的例子在网上有很多，就不写了。
这样写的话，会有一些东西需要了解。
子类化QThread的方法，只有run函数里面的内容是执行在子线程里的，其他的部分，比如槽函数什么的还是在主线程里执行（假设是在主线程开启的该子线程）。
还有一种方法，是子类化QObject，新建一个线程，然后使用MoveToThread把这个类的对象移到新建的线程中，这种做法使得它所有的槽函数都是执行在新开辟的线程里面。
如果直接（QObject对象）.abc()的话，这个成员函数是在主进程内执行，可能会出现"QObject::killTimer: timers
cannot be stopped from another thread"的运行错误。
使用第二种方法的话，貌似会遇到这样的问题：如果在一个槽函数中把子线程阻塞，其他的槽函数无法接受来自主线程

㈡ C语言编译器是否支持多线程

C语言编译器有很多，只要不是太旧的都支持多线程。C语言本身是没有多线程的概念的，都是操作系统提供支持，所以不同操作系统中的多线程实现起来可能完全不一样。

㈢ vs2010 怎样编译多线程程序

是不是在同一个解决方案中?
在的话直接编译解决方案可以了.编译器会自动从底层编译到表现层.

多进程的编译和单进程的编译有什么不一样吗?

㈣ 为什么有时编译选项要改成多线程才能编译通过，而 单线程就不行呢

主要是libc（C函数）库不同，有时链接时会看到libcd.lib/libc.lib/libcmt.lib...这些东东，就是针对不同的线程环境所使用的。不过在VS2005之后，不再使用单线程库了，它只使用libc*mt.lib，也就是有很多老程序代码在VS2005下找不到LIBCD.lib的原因。
如果你在程序中使用了_beginthread之类的函数，那么就会链接到多线程的c函数库，单线程选项当然不能使用了。
而使用FORCE:MUTIPLE和这个没有多大关系，它可能在同时使用了单线程库和多线程库时起到了忽略多个重叠符号错误的作用。

㈤ 编译器如何处理多线程程序

这是一个多线程例子，里面只有两个线程，是生产者/消费者模式，已编译通过，注释很详细，
如下：

/* 以生产者和消费者模型问题来阐述linux线程的控制和通信你
生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。
缓冲区有N个，是一个环形的缓冲池。
*/
#include <stdio.h>
#include <pthread.h>

#define BUFFER_SIZE 16

struct prodcons
{
int buffer[BUFFER_SIZE];/*实际存放数据的数组*/
pthread_mutex_t lock;/*互斥体lock，用于对缓冲区的互斥操作*/
int readpos,writepos; /*读写指针*/
pthread_cond_t notempty;/*缓冲区非空的条件变量*/
pthread_cond_t notfull;/*缓冲区未满 的条件变量*/
};

/*初始化缓冲区*/
void pthread_init( struct prodcons *p)
{
pthread_mutex_init(&p->lock,NULL);
pthread_cond_init(&p->notempty,NULL);
pthread_cond_init(&p->notfull,NULL);
p->readpos = 0;
p->writepos = 0;
}

/*将产品放入缓冲区，这里是存入一个整数*/
void put(struct prodcons *p,int data)
{
pthread_mutex_lock(&p->lock);
/*等待缓冲区未满*/
if((p->writepos +1)%BUFFER_SIZE ==p->readpos)
{
pthread_cond_wait(&p->notfull,&p->lock);
}
p->buffer[p->writepos] =data;
p->writepos++;
if(p->writepos >= BUFFER_SIZE)
p->writepos = 0;
pthread_cond_signal(&p->notempty);
pthread_mutex_unlock(&p->lock);
}
/*从缓冲区取出整数*/
int get(struct prodcons *p)
{
int data;
pthread_mutex_lock(&p->lock);
/*等待缓冲区非空*/
if(p->writepos == p->readpos)
{
pthread_cond_wait(&p->notempty ,&p->lock);//非空就设置条件变量notempty
}
/*读书据，移动读指针*/
data = p->buffer[p->readpos];
p->readpos++;
if(p->readpos == BUFFER_SIZE)
p->readpos = 0;
/*设置缓冲区未满的条件变量*/
pthread_cond_signal(&p->notfull);
pthread_mutex_unlock(&p->lock);
return data;
}
/*测试：生产站线程将1 到1000的整数送入缓冲区，消费者线程从缓冲区中获取整数，两者都打印信息*/
#define OVER (-1)
struct prodcons buffer;
void *procer(void *data)
{
int n;
for( n=0;n<1000;n++)
{
printf("%d ------>\n",n);
put(&buffer,n);
}
put(&buffer,OVER);
return NULL;
}
void *consumer(void *data)
{
int d;
while(1)
{
d = get(&buffer);
if(d == OVER)
break;
else
printf("----->%d\n",d);
}
return NULL;
}
int main()
{
pthread_t th_p,th_c;
void *retval;
pthread_init(&buffer);
pthread_create(&th_p,NULL,procer,0);
pthread_create(&th_c,NULL,consumer,0);
/*等待两个线程结束*/
pthread_join(th_p, &retval);
pthread_join(th_c,&retval);
return 0;
}

㈥ linux里面线程编译运行问题

#gcc a.c -o a #此句的-o a说明输出目标文件为“a”；
#gcc -Wall-lpthread threadcreatetest.c #此句未注明输出目标文件名，系统默认输出为a.out，所以编译之后执行./a.out文件。
如果上句也没有指明“ -o a ”的话，输出也是a.out，你可以试试

㈦ 什么是多线程编程

多线程编程技术是java语言的重要特点。多线程编程的含义是将程序任务分成几个并行的子任务。特别是在网络编程中，你会发现很多功能是可以并发执行的。 比如网络传输速度较慢、用户输入速度较慢，你可以用两个独立的线程去完成这两个功能，而不影响正常的显示或其它功能。 多线程是与单线程比较而言的，普通的Windows采用单线程程序结构，其工作原理是：主程序有一个消息循环，不断从消息队列中读入消息来决定下一步所要干的事情，一般是针对一个函数，只有等这个函数执行完之后，主程序才能接收另外的消息来执行。比如子函数功能是在读一个网络数据，或读一个文件，只有等读完这个数据或文件才能接收下一个消息。在执行这个子函数过程中你什么也不能干。但往往读网络数据和等待用户输入有很多时间处于等待状态，多线程利用这个特点将任务分成多个并发任务后，就可以解决这个问题。Java中的线程类 1.扩展java.lang.Thread类，用它覆盖Thread类的run方法。 2.生成实现java.lang.Runnable接口的类并将其它的实例与java.lang.Thread实例相关联。 Thread类是负责向其它类提供线程支持的最主要的类，要使用一个类具有线程功能，在Java中只要简单地从Thread类派生一个子类就可以了扩展Thread类，如printThread.java。 Thread类最重要的方法是run方法。run方法是新线程执行的方法，因此生成java.lang.Thread的子类时，必须有相应的run方法。 //PrintThread.java public class PrintThread extends Thread//继承Tread类 private int count=0 //定义一个count变量用于统计打印的次数并共享变量 public static void mainString args//main方法开始 PrintThread p=new PrintThread//创建一个线程实例 p.start//执行线程 for{;;}//主线程main方法执行一个循环，for执行一个死循环count++ System.out.printcount+″：Main\n″//主线程中打印count +“main”变量的值，并换行 public void run//线程类必须有的run（）方法for{;;}count++ System.out.printcount+″：Thread\n″ 上面这段程序便是继承java.lang.Tread并覆盖run的方法。用Java 虚拟机启动程序时，这个程序会先生成一个线程并调用程序主类的main方法。这个程序中的main方法生成新线程，连接打印“Thread”。在启动线程之后，主线程继续打印“Main”。 编译并执行这个程序，然后立即按“Ctrl+C”键中断程序，你会看到上面所述的两个线程不断打印出：XXX：main…..XXX：Thread…. XXX代表的是数字，也就是上面count的值。在笔者的机器上，不同时刻这两个线程打印的次数不一样，先打印20个main（也就是先执行20次主线程）再打印出50次Thread，然后再打印main…… 提示：为了便于查看该程序的执行结果，你可以将执行结果导入一个文本文件，然后打开这个文件查看各线程执行的情况。如运行： javac PrintThread.java Java PrintThread1.txt 第一个命令javac PrintThread.java是编译java程序，第二个是执行该程序并将结果导入1.txt文件。当然你可以直接执行命令：java

㈧ linux下c、c++下多线程编译

C语言要求除main函数外 所有的函数必须先声明才能使用 你可以在函数定义的时候一起声明这个函数 但是在这个函数定义之前不能使用这个函数
下面用通俗点的语言讲: 你在main函数中调用了thread函数, 但是如果你把void *thread(void *vargp);删掉了, 那么编译器就找不到这个函数了(因为编译器是从前往后编译这个程序的) 因此编译器是通不过的
有两种方法, 一种就是像你之前写的 先声明这个函数 第二种是把void *thread(void *vargp){...}放到main函数的前面.
有些返回值和参数类型为int型的函数也可以不用声明, 编译器也能通过, 不过这是不建议的 也是不符合标准的
标准建议每个函数都应该给出它们的显式的声明
希望你懂了 嘿嘿

㈨ java多线程编译，求代码！

public class Main {

private static ArrayBlockingQueue<String> file_q = new ArrayBlockingQueue<String>(1000);
private static ArrayBlockingQueue<String> console_q = new ArrayBlockingQueue<String>(1000);

public static void main(String[] args) {
new Thread(new Thread_A()).start();
new Thread(new Thread_B()).start();
new Thread(new Thread_C()).start();
}

static class Thread_A implements Runnable {

public void run() {
BufferedReader thread_a = new BufferedReader(new InputStreamReader(System.in));
String inputString;
while (true) {
try {
inputString = thread_a.readLine();
char firstChar = inputString.charAt(0);
if (firstChar >= 'A' && firstChar <= 'Z') {
file_q.put(inputString);//大写，放入写文件队列
} else {
console_q.put(inputString);//非大写，放入写控制台队列
}
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

/**
* 文件输出线程
*/
static class Thread_B implements Runnable {
public void run() {
while (true) {
try {
String to_write_file_str = file_q.poll(300L, TimeUnit.MILLISECONDS);
if (null != to_write_file_str && to_write_file_str.trim().length() > 0) {
RandomAccessFile randomFile = new RandomAccessFile("E:/test.txt", "rw");
long fileLength = randomFile.length();
randomFile.seek(fileLength);
randomFile.writeBytes(String.format("%s\r\n", to_write_file_str));
randomFile.close();
System.out.println("Thread B writed!");
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

/**
* 控制台输出线程
*/
static class Thread_C implements Runnable {
public void run() {
while (true) {
try {
String to_write_console_str = console_q.poll(300L, TimeUnit.MILLISECONDS);
if (null != to_write_console_str && to_write_console_str.trim().length() > 0)
System.out.printf("Thread C say: %s%n", to_write_console_str);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

}

㈩ LINUX下多线程编译问题

你编译的时候有加多线程连接选项吗？ 要加上 -lpthread 或者 -pthread (尽量选后者)
例如 gcc -pthread -o test main.cpp

另外你的线程创建的不对，函数指针不能强转类型（这里也不用转）
pthread_create(&procter_t,NULL,(void*)procter_f,NULL);
pthread_create(&consumer_t,NULL,(void*)consumer_f,NULL);

应该是
pthread_create(&procter_t,NULL,procter_f,NULL);
pthread_create(&consumer_t,NULL,consumer_f,NULL);