线程和进程有什么区别
1、首先是定义
进程：是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，又是调度运行的基本单位，是系统中的并发执行的单位。
线程：单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。
2、一个线程只能属于一个进程，但是一个进程可以拥有多个线程。多线程处理就是允许一个进程中在同一时刻执行多个任务。
3、线程是一种轻量级的进程，与进程相比，线程给操作系统带来侧创建、维护、和管理的负担要轻，意味着线程的代价或开销比较小。
4、线程没有地址空间，线程包含在进程的地址空间中。线程上下文只包含一个堆栈、一个寄存器、一个优先权，线程文本包含在他的进程 的文本片段中，进程拥有的所有资源都属于线程。所有的线程共享进程的内存和资源。 同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段， 寄存器的内容，栈段又叫运行时段，用来存放所有局部变量和临时变量。-线程进程
5、父和子进程使用进程间通信机制，同一进程的线程通过读取和写入数据到进程变量来通信。
6、进程内的任何线程都被看做是同位体，且处于相同的级别。不管是哪个线程创建了哪一个线程，进程内的任何线程都可以销毁、挂起、恢复和更改其它线程的优先权。线程也要对进程施加控制，进程中任何线程都可以通过销毁主线程来销毁进程，销毁主线程将导致该进程的销毁，对主线程的修改可能影响所有的线程。-线程
7、子进程不对任何其他子进程施加控制，进程的线程可以对同一进程的其它线程施加控制。子进程不能对父进程施加控制，进程中所有线程都可以对主线程施加控制。
相同点：
进程和线程都有ID/寄存器组、状态和优先权、信息块，创建后都可更改自己的属性，都可与父进程共享资源、都不鞥直接访问其他无关进程或线程的资源。进程和线程
VC++ 多线程
你要考虑到你开辟线程以后，如果线程还没执行到flag=false，那么此时flag还是true，但是主线程已经if(flag==true)了，你就死了。
你创建线程用的_beginthreadex函数是吧？（如果是_beginthread，请换成_beginthreadex），这个函数有返回值，可以强制转为HANDLE类型：
HANDLE hThread = (HANDLE) _beginthreadex(...);
然后这个hThread是可以等待的：
WaitForSingleObject(hThread, INFINITE);
线程结束之前，这个WaitForSingleObject函数不会返回。
等待完毕之后关闭HANDLE释放资源：
CloseHandle(hThread);
连起来就是：
for(....)
{
HANDLE hThread = (HANDLE) _beginthreadex(开辟线程;
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);
}
线程函数里
{
线程函数内容;
return 0
}
-线程进程
Java中线程怎么同步
1、使用线程类自带的join方法，将子线程加入到主线程，在子线程执行完之后，在执行主线程逻辑。
例如
[java] view plain copy
public static void joinDemo()
throws InterruptedException
{
System.out.println(“=========Test with join=====“);
JoinWorker worker1 = new JoinWorker(“worker1“);
JoinWorker worker2 = new JoinWorker(“worker2“);
worker1.start();
worker2.start();
worker1.join();
worker2.join();
doSuperWork();
}
- 2、使用JDK的并发包中的CountDownLatch类， 使用CountDownLatch，每个线程调用其countDown方法使计数器-1，主线程调用await方法阻塞等待，直到CountDownLatch计数器为0时继续执行，例如
static class CountDownLatchWorker extends Thread
{
String workerName;
CountDownLatch latch;
public CountDownLatchWorker(String workerName, CountDownLatch latch)
{
this.workerName = workerName;
this.latch = latch;
}
public void run()
{
System.out.println(“Sub Worker “ + workerName + “ do work begin at “
+ sdf.format(new Date()));
new ThreadWaitDemo().doSomeWork();// 做实际工作
System.out.println(“Sub Worker “ + workerName + “ do work complete at “
+ sdf.format(new Date()));
latch.countDown();// 完成之后，计数器减一
}
}
- 主线程中调研await方法阻塞等待，直到所有线程完成
public static void countDownLatchDemo()
throws InterruptedException
{
System.out.println(“=========Test with CountDownLatch=====“);
CountDownLatch latch = new CountDownLatch(2);
CountDownLatchWorker worker1 = new CountDownLatchWorker(“worker1“, latch);
CountDownLatchWorker worker2 = new CountDownLatchWorker(“worker2“, latch);
worker1.start();
worker2.start();
//主线程阻塞等待
latch.await();
doSuperWork();
}
public static void cyclicBarrierDemo()
throws InterruptedException, BrokenBarrierException
{
System.out.println(“=========Test with CyclicBarrier=====“);
CyclicBarrier cb = new CyclicBarrier(2, new Runnable()
{
// 将主线程业务放到CyclicBarrier构造方法中，所有线程都到达Barrier时执行
@SuppressWarnings(“static-access“)
public void run()
{
new ThreadWaitDemo().doSuperWork();
}
});// 设定需要等待两个线程
ExecutorService executor = Executors.newFixedThreadPool(2);
CyclicBarrierWorker worker1 = new CyclicBarrierWorker(“worker1“, cb);
CyclicBarrierWorker worker2 = new CyclicBarrierWorker(“worker2“, cb);
executor.execute(worker1);
executor.execute(worker2);
executor.shutdown();
}
- 4、使用JDK并发包中的Executors框架，ExecutorService的的invokeAll方法调研callable集合，批量执行多个线程，在invokeAll方法结束之后，再执行主线程其他业务逻辑
public static void callableDemo()
throws InterruptedException
{
System.out.println(“=========Test with Callable=====“);
List《Callable《Integer》》 callList = new ArrayList《Callable《Integer》》();
ExecutorService exec = Executors.newFixedThreadPool(2);
// 采用匿名内部类实现
callList.add(new Callable《Integer》()
{
public Integer call()
throws Exception
{
System.out.println(“Sub Worker worker1 do work begin at “ + sdf.format(new Date()));
new ThreadWaitDemo().doSomeWork();// 做实际工作
System.out.println(“Sub Worker worker1 do work complete at “
+ sdf.format(new Date()));
return 0;
}
});
callList.add(new Callable《Integer》()
{
public Integer call()
throws Exception
{
System.out.println(“Sub Worker worker2 do work begin at “ + sdf.format(new Date()));
new ThreadWaitDemo().doSomeWork();// 做实际工作
System.out.println(“Sub Worker worker2 do work complete at “
+ sdf.format(new Date()));
return 0;
}
});
exec.invokeAll(callList);
exec.shutdown();
doSuperWork();
}
- 5、这种过于恶心，只简单说一下方法，主线程创建一个线程List，将每个子线程保存到列表中，然后定期轮询列表中子线程状态，当所有线程都完成之后，再执行主线程逻辑
首先，定义子线程
[java] view plain copy
[html] view plain copy
3、使用JDK并发包CyclicBarrier，CyclicBarrier类似于CountDownLatch也是个计数器， 不同的是CyclicBarrier的await()方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。 在这之后，如果再次调用 await()方法，计数就又会变成 N-1，新一轮重新开始CyclicBarrier初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。-线程
示例如下
[java] view plain copy
示例如下
[java] view plain copy
