linux开启线程

⑴ linux 线程问题

主要理解在fork函数。
你可以参考
http://hi..com/huifeng00/blog/item/c7e9a4c6c5e6eac739db49b6.html
这会产生分支，
fork会产生一个子进程。
根据fork的返回值的不同运行不同的代码。
在子进程返回值是0，而父进程就是调用这个函数的进程中返回的则是进程的ID也就是>0。
所以在子进程中执行
pthread_attr_init(&attr);
pthread_create(&tid,&attr,runner,NULL);
pthread_join(tid,NULL);
printf("CHILD:value=%d",value);
这个子进程会启动一个线程
void*runner(void*param){
value=5;
pthread_exit(0);
}
让value=5;
所以输出
CHILD:value=5；
而父进程则执行
wait(NULL);
printf("PARENT:value=%d",value);
由于wait()所以它会暂停父进程，等待子进程结束。
子进程结束后，然后父进程运行输出
PARENT:value=0
至于为什么是0，因为子进程和父进程的数据是在内存中各有一份的。
子进程只是改变了它那份。父进程中还是0.

⑵ linux线程可以创建线程吗

创建线程一般都是在主线程里面创建，因为在主线程里面能够对线程进行管理控制，而且还有很重要的一点，就是Linux编程中使用线程的好处是可以共享变量，这在主线程的main函数里面更加方便，所以没有在线程中再创建线程的用法。既然想在线程中再创建线程，为何不用fork复制进程呢，Linux的进程开销是非常小的。

⑶ Linux多线程实现线程间不停的切换

你这个问题很有意思。第一次执行的时候，可以看出，能执行0~6共7次；第二次的时候，从6开始，到5，只有2次了，并且以后都是只有2次。
基于你的描述，我想可以用互斥信号量来做。
1、初始化2个信号量pmutex1（有资源）， pmutex2（无资源），初始化gnum=0
2、启动两个线程
2.1 线程1
lock_the_mutex_signal(pmutex1); // 上锁自身线程，首次可执行
while (gnum < 5) {
do_sth(); // 做你的业务逻辑

gnum++; // 增加执行次数

} // end while()
unlock_the_mutex_signal(pmutex2); // 解锁另一线程
2.2 线程2

lock_the_mutex_signal(pmutex2); // 上锁自己，首次执行将阻塞，并交出CPU
while (gnum > 5) {
do_sth(); // ...

gnum--; // ...

} // end while()
unlock_the_mutex_signal(pmutex1); // release the lock
PS：如果你不是非常严格地（从系统级杜绝不该被执行的线程被调用）要求线程切换的话，这个逻辑应该可以工作。自己没有试，希望你明白我的思想，如有错误，自己再修改一下。

⑷ linux 一个进程 最多开多少线程

32为linux系统最大内存地址4G，0-3GB的给用户进程(User Space)使用，3-4GB给内核使用
stack size (kbytes, -s) 10240表示线程堆栈大小
3G/10M=最大线程数，但实际会比这个数小一点，因为程序本身占内存，还有些管理线程
可以使用ulimit -s来设置stack size，设置的小一点开辟的线程就多。

同时/usr/include/bits/local_lim.h中的PTHREAD_THREADS_MAX限制了进程的最大线程数
/proc/sys/kernel/threads-max中限制了系统的最大线程数

你自己写个简单的代码就能测试出自己系统最大可以开多少线程

#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>

void *foo(void *param)
{
}

int main()
{
int i = 0;
pthread_t thread;
while(1)
{
if(pthread_create(&thread,NULL,foo,NULL) != 0)
break;
i++;
}
printf("i=%d\n",i);
return 0;
}

⑸ Linux下多线程的如何执行

主线程结束，则进程结束，属于该进程的所有线程都会结束，可以在主线程中join，也可以在主线程中加死循环。

⑹ C++在linux下怎么多线程

#ifndefTHREAD_H_
#defineTHREAD_H_
#include<unistd.h>
#include<pthread.h>
classRunnable
{
public:
//运行实体
virtualvoidrun()=0;
};
//线程类
classThread:publicRunnable
{
private:
//线程初始化号
staticintthread_init_number;
//当前线程初始化序号
intcurrent_thread_init_number;
//线程体
Runnable*target;
//当前线程的线程ID
pthread_ttid;
//线程的状态
intthread_status;
//线程属性
pthread_attr_tattr;
//线程优先级
sched_paramparam;
//获取执行方法的指针
staticvoid*run0(void*pVoid);
//内部执行方法
void*run1();
//获取线程序号
staticintget_next_thread_num();
public:
//线程的状态－新建
staticconstintTHREAD_STATUS_NEW=0;
//线程的状态－正在运行
staticconstintTHREAD_STATUS_RUNNING=1;
//线程的状态－运行结束
staticconstintTHREAD_STATUS_EXIT=-1;
//构造函数
Thread();
//构造函数
Thread(Runnable*target);
//析构
~Thread();
//线程的运行体
voidrun();
//开始执行线程
boolstart();
//获取线程状态
intget_state();
//等待线程直至退出
voidjoin();
//等待线程退出或者超时
voidjoin(unsignedlongmillis_time);
//比较两个线程时候相同，通过current_thread_init_number判断
booloperator==(constThread*other_pthread);
//获取this线程ID
pthread_tget_thread_id();
//获取当前线程ID
staticpthread_tget_current_thread_id();
//当前线程是否和某个线程相等，通过tid判断
staticboolis_equals(Thread*iTarget);
//设置线程的类型:绑定/非绑定
voidset_thread_scope(boolisSystem);
//获取线程的类型:绑定/非绑定
boolget_thread_scope();
//设置线程的优先级，1－99，其中99为实时，意外的为普通
voidset_thread_priority(intpriority);
//获取线程的优先级
intget_thread_priority();
};
intThread::thread_init_number=1;
inlineintThread::get_next_thread_num()
{
returnthread_init_number++;
}
void*Thread::run0(void*pVoid)
{
Thread*p=(Thread*)pVoid;
p->run1();
returnp;
}
void*Thread::run1()
{
thread_status=THREAD_STATUS_RUNNING;
tid=pthread_self();
run();
thread_status=THREAD_STATUS_EXIT;
tid=0;
pthread_exit(NULL);
}
voidThread::run()
{
if(target!=NULL)
{
(*target).run();
}
}
Thread::Thread()
{
tid=0;
thread_status=THREAD_STATUS_NEW;
current_thread_init_number=get_next_thread_num();
pthread_attr_init(&attr);
}
Thread::Thread(Runnable*iTarget)
{
target=iTarget;
tid=0;
thread_status=THREAD_STATUS_NEW;
current_thread_init_number=get_next_thread_num();
pthread_attr_init(&attr);
}
Thread::~Thread()
{
pthread_attr_destroy(&attr);
}
boolThread::start()
{
returnpthread_create(&tid,&attr,run0,this);
}
inlinepthread_tThread::get_current_thread_id()
{
returnpthread_self();
}
inlinepthread_tThread::get_thread_id()
{
returntid;
}
inlineintThread::get_state()
{
returnthread_status;
}
voidThread::join()
{
if(tid>0)
{
pthread_join(tid,NULL);
}
}
voidThread::join(unsignedlongmillis_time)
{
if(tid==0)
{
return;
}
if(millis_time==0)
{
join();
}
else
{
unsignedlongk=0;
while(thread_status!=THREAD_STATUS_EXIT&&k<=millis_time)
{
usleep(100);
k++;
}
}
}
boolThread::operator==(constThread*other_pthread)
{
if(other_pthread==NULL)
{
returnfalse;
}if(current_thread_init_number==(*other_pthread).current_thread_init_number)
{
returntrue;
}
returnfalse;
}
boolThread::is_equals(Thread*iTarget)
{
if(iTarget==NULL)
{
returnfalse;
}
returnpthread_self()==iTarget->tid;
}
voidThread::set_thread_scope(boolisSystem)
{
if(isSystem)
{
pthread_attr_setscope(&attr,PTHREAD_SCOPE_SYSTEM);
}
else
{
pthread_attr_setscope(&attr,PTHREAD_SCOPE_PROCESS);
}
}
voidThread::set_thread_priority(intpriority)
{
pthread_attr_getschedparam(&attr,&param);
param.__sched_priority=priority;
pthread_attr_setschedparam(&attr,&param);
}
intThread::get_thread_priority(){
pthread_attr_getschedparam(&attr,&param);
returnparam.__sched_priority;
}
#endif/*THREAD_H_*/

⑺ linux内核如何打开超线程

通常来说，超线程功能在bios里是默认开启的，
如果你cpu支持超线程，则会自动模拟为物理核心x2；
如果超线程没有开启，可以在开机的时候，进入bios里，找hyper-threading项，改为enabled就是开启超线程

⑻ linux 多线程cpu运行时间

这个月时间比较长的，因为这个度现成的CPU使用起来非常的好

⑼ linux如何进行线程管理

方法一：PS
在ps命令中，“-T”选项可以开启线程查看。下面的命令列出了由进程号为<pid>的进程创建的所有线程。
1.$ ps -T -p <pid>

“SID”栏表示线程ID，而“CMD”栏则显示了线程名称。

方法二： Top
top命令可以实时显示各个线程情况。要在top输出中开启线程查看，请调用top命令的“-H”选项，该选项会列出所有Linux线程。在top运行时，你也可以通过按“H”键将线程查看模式切换为开或关。
1.$ top -H

要让top输出某个特定进程<pid>并检查该进程内运行的线程状况：
$ top -H -p <pid>