实战Java高并发程序设计（二）Java并行程序基础

进程与线程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。进程是程序的容器。

线程（Thread）是CPU调度的最下单位，它是建立在进程的基础上运行的。

使用多线程而不使用多进程的原因是，线程间的切换和调度的成本远小于进程。

线程的State有一下几种：

(1) NEW：线程还没有开始执行。

(2) RUNNABLE:：线程正在JVM中执行。

(3) BLOCKED：线程被阻塞并等待一个监听锁

(4) WAITING：线程无限期等待另一条线程执行特定的操作。

(5) TIMED_WAITING：在特定时间内等待另外一条线程执行。

(6) TERMINATED：线程退出。

线程的操作

Thread的run方法和start方法的区别（重要）

start方法会新建一个线程，并让这个线程执行run方法。

run方法不会新建线程，而是在当前线程中串行执行run方法。

Thread有一个重要的构造函数

Public Thread(Runnable target)

。此时执行start或者run方法时，就会执行target对象的run方法。

线程终止，不要使用stop()方法，调用这个方法会立即终止一个线程，但是由于它太过暴力，可能会出现数据不一致的问题。我们可以自定义方法，让线程在某个合适的位置退出。

boolean flag = false;
public void stopMe(){//该方法用于停止该线程
flag = true;
}
@Override
public void run(){
while(true){
if(flag){
break;
}
//Do Something
}
}

线程中断不会让线程马上退出，而是给线程发送一个通知，告诉它有人希望它退出。中断能够作用在sleep()或者wait()的操作上。

public static void Thread.interrupt() //中断线程

public static boolean Thread.isInterrupted() //判断是否被中断

public static boolean Thread.interrupted() //判断是否被中断，并清除当前中断状态

注意：Thread.sleep()方法由于中断而抛出异常后，会清空中断标记，如果sleep外面嵌套循环，我们需要在

catch

中在再次设置中断标记位：

Thread.currentThread().interrupt();

，否则第二次循环无法捕捉到这个中断。

等待(wait)和通知(notify)

   这两个方法是Object类的方法，任何对象都能够调用。

   Object.wait()和Object.notify)方法调用有个前提，它必须包含在对应的

synchronzied

的语句中:

synchronized(object){
object.wait();
object.notify);
}

这是因为在执行wait和notify的时候，需要先获得object的监视器。

挂起(suspend)和继续执行(resume)

   suspend不推荐使用，因为它在暂停线程的同时，不会释放任何资源。如果resume()操作意外地在suspend()之前执行，那么被挂起的线程可能很难继续执行，那么这些资源就无法被释放。而且，对于被挂起的线程，从线程的状态上看还是Runnable的，这会严重影响我们对系统当前状态的判断。

等待线程结束(join)和谦让(yield)

join的作用是让该线程执行完，当前线程再继续执行。其本质是在当前线程上调用wait()。请看如下代码:

puiblic volatile static int i = 0;
public static class MyThread extends Thread{
public void run(){
for(i=0;i<100000;i++);
}
}
public static void main(){
MyThread mt = new MyThread();
mt.start();
mt.join();
System.out.println(i);
}

   如果没有

mt.join()

，那么输出的i很有可能是0或者一个很小的值，但是有了

mt.join()

，输出的i肯定是100000。

yield的作用是使得当前线程让出CPU，但是之后该线程还是会继续抢夺CPU资源。我们可以对某个不重要或者优先级较低的线程，并且害怕它占用太多的CPU资源，那么就可以适当地调用

Thread.yield()

。

volatile关键字

   该关键字是用来保证某个变量的可见性的。具体应用如下:

public class A{
public volatile static long t=0;
public static class AddThread implements Runnalbe{
private long value;
public AddThread (long value){
this.value = value;
}
public void run(){
while(true){
A.t = value;
}
}
}
}

   我们知道，对long的操作本身是没有原子性的，如果不加

volatile

关键词，对A.t的赋值操作可能会失败，出现错误值。但是加了该关键字之后，就能保证对long操作的原子性。

   但是volatile关键字无法保证

i++

的原子性，这需要锁来保证。但是volatile能够保证数据的可见性和有序性。

守护线程（Daemon）

   在一个Java应用中，如果只有守护线程，那么Java虚拟机就会自然退出。注意：守护线程的设置必须要在线程start之前，否则设置会失败。

线程优先级（priority）

在Java中，线程优先级分为10级（1到10），数字越大，优先级越高。一般可以用三个内置静态标量表示：

public final static int MIN_PRIORITY = 1;

public final static int NORM_PRIORITY = 5;

public final static int MAX_PRIORITY = 10;

synchronized关键字

   synchronized关键字得到作用是实现线程同步。它的作用是对同步的代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程间的安全性。它有以下三种用法：

指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。

Object obj = new Object();
synchronized(obj){
}

直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

Object obj = new Object();
public synchronized void increase(){
i++;
}
public void run(){
for(int i=0;i<100000;i++){
increase();
}
}
public static void main(){
Thread t1 = new Thread(obj);
Thread t2 = new Thread(obj);
}

直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

public static synchronized void increase(){
i++;
}

   除了用于线程同步、确保线程安全外，它还可以保证线程间的可见性和有序性。

   注意:以下代码会导致加锁失败。因为Integer属于不变对象，即该对象一旦创建之后，它的值就不会改变。当i的值改变时，会新创建一个对象，因此i随着自增，在不断创建新对象。

public static Integer i = 0;
public void run(){
for(int j=0;j<10000;j++){
synchronized(i){
i++;
}
}
}