<jdk7学习笔记>读书笔记-线程

Tread和Runnable

定义线程

• 实现Runnable接口，重写run()方法

• 继承Thread类,重写run()方法

启动线程

        Runnable tortoise=new Tortoise();
        Thread thread1=new Thread(tortoise);
        thread1.start();

        Thread thread1=new Tortoise();
        thread1.start();

线程生命周期

daemon线程

主线程会从main()方法开始执行，直到main()方法结束后停止jvm.如果主线程中启动了额外线程,则主线程默认会等到被启动的所有额外线程都执行完run()方法才会终止jvm.

public class Daemon implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("TheViper");
        }
    }
    public static void main(String[] args){
        Thread thread=new Thread(new Daemon());
        //thread.setDaemon(true);
        thread.start();
    }
}

TheViper
TheViper
TheViper
...

控制台会不停的打印。如果把注释去掉，thread.setDaemon(true),则在所以非daemon线程都结束时，jvm自动终止。
默认所有从daemon线程产生的线程也是daemon线程。

线程基本状态图

启动线程后，基本状态可分为可执行(runnable),阻塞(blocked),执行中(running).

在一个时间点上，一个cpu只能执行一个线程，只是cpu会不断切换线程。可以用Thread的setPriority()方法设置线程的优先级，设定值1-10,默认为5.优先级越高的线程，越有机会抢占cpu.
线程进入blocked状态可能的情况:

• 调用Thread.sleep()方法

• 进入synchronized前，对竞争对象的锁定

• 调用wait()方法阻断

• 等待io完成

• ...

一个处于blocked状态的线程，可由另一个线程调用interrupt()方法，让它离开blocked状态。

public class Daemon implements Runnable{
    @Override
    public void run() {
        System.out.println("TheViper");
        try {
            Thread.sleep(3000);//进入blocked状态
        } catch (InterruptedException e) {
            System.out.println("离开blocked状态");
        }
    }
    public static void main(String[] args){
        Thread thread=new Thread(new Daemon());
        thread.start();
        thread.interrupt();
    }
}

TheViper
离开blocked状态

安插线程

假设线程A正在运行，这时线程B想占用cpu运行，等它运行完后，继续运行线程A.这种情况可以使用join()方法.
未使用join()

public class Daemon implements Runnable{
    @Override
    public void run() {
        System.out.println("线程开始");
        try {
            Thread.sleep(3000);
            System.out.println("线程执行");
        } catch (InterruptedException e) {
            System.out.println("离开blocked状态");
        }
        System.out.println("线程结束");
    }
    public static void main(String[] args){
        Thread thread=new Thread(new Daemon());
        thread.start();
        System.out.println("主线程开始");
    }
}

主线程开始
线程开始
线程执行
线程结束

使用join()

public class Daemon implements Runnable{
    @Override
    public void run() {
        System.out.println("线程开始");
        try {
            Thread.sleep(3000);
            System.out.println("线程执行");
        } catch (InterruptedException e) {
            System.out.println("离开blocked状态");
        }
        System.out.println("线程结束");
    }
    public static void main(String[] args) throws InterruptedException{
        Thread thread=new Thread(new Daemon());
        thread.start();
        thread.join();
        System.out.println("主线程开始");
    }
}

线程开始
线程执行
线程结束
主线程开始

程序启动后就开始运行主线程(因为新建线程使用了sleep(),让新建线程进入blocked状态，主线程可以占用cpu),对新建的线程使用join(),将其加入到主线程后，原本应该一来就运行的主线程，现在需要等到后面新建的线程执行完后，才能继续执行。
如果加入的线程处理时间太久，可以在join（）时指定时间，如join(10000),表示加入的线程最多只能处理10秒。

停止线程

线程完成run()方法后，就进入dead状态。这时不能再次调用start()方法。
Thread类上的stop()方法是过时方法。
如果要停止线程，最好自行操作，让线程跑完应有的流程，而不是调用stop()方法

...
private boolean isContinue=true;
public void stop(){
    this.isContinue=false;
}
public void run(){
    while(isContinue){
        ...
    }
}
...

synchronized

public synchronized void add(Object o){...}

每个对象都有一个内部锁定。被标示为synchronized的区块会被监控，任何线程要执行synchronized区块都必须先获得指定的对象锁定。
如果线程A已获得对象锁定开始执行sychronized区块，线程B也想执行synchronized区块，线程B会因为无法获得对象锁定而进入等待对象锁定状态，直到线程A释放锁定(如执行完synchronized区块)。
在方法上标示sychronized,则执行方法必须获得该实例的指定。
实际上等待对象锁定时，也会进入线程的blocked状态

synchronized不仅可以声明在方法上，也可以描述句方式使用

public void add(Object o){
    synchronized(this){
        ...
    }
}

List<String> list=new ArrayList<String>();
synchronized(list){
    ...
    list.add("TheViper");//让ArrayList线程安全
}

这种方式不用锁定整个方法，只锁定会发生竞争状况的区块。获得锁定的线程执行完这个区块后，会立即释放锁定，其他线程就有机会再竞争这个锁定.
相比于将整个方法声明为synchronized,这种方式更有效率。
可以提供不同的对象作为锁定的来源

private Object lock1=new Object();
private Object lock2=new Object();
public void method1(){
    synchronized(lock1){
        data1++;
        ...
    }
}
public void method2(){
    synchronized(lock2){
        data2++;
        ...
    }
}

在两个synchronized区块里，没有公共的数据，方法。当有一个线程执行method1()而另一个线程执行method2()时，并不会引起共享存取问题,而且一个线程不会因为另一个线程获得锁定而阻塞.
java的synchronized提供的是可重入同步,也就是线程获得某对象锁定后，若执行过程中又要执行synchronized,而这个锁定对象的来源又和前面的是同一个，则可以直接执行。

死锁

public class Resource {
    synchronized void doSome(){
        
    }
    public synchronized void deal(Resource res){
        res.doSome();
    }
}

public class TheadDemo extends Thread{
    Resource res1;
    Resource res2;
    TheadDemo(Resource res1,Resource res2){
        this.res1=res1;
        this.res2=res2;
    }
    @Override
    public void run(){
        for(int i=0;i<10;i++)
            this.res1.deal(this.res2);
    }
    public static void main(String[] args){
        Resource res1=new Resource();
        Resource res2=new Resource();
        Thread thread1=new TheadDemo(res1,res2);
        Thread thread2=new TheadDemo(res2,res1);
        thread1.start();
        thread2.start();
    }
}

这段代码可能出现死锁，也可能不会。
如果出现的话，原因在于

1. Thread thread1=new TheadDemo(res1,res2)=>this.res1.deal(this.res2)时，thread1获得res1的锁定

2. Thread thread2=new TheadDemo(res2,res1)=>this.res2.deal(this.res1),thread2获得res2的锁定

3. thread1线程res2.doSome(),准备获得res2的锁定，但是res2的锁定被thread2线程占用，于是thread1线程进入blocked状态

4. thread2线程res1.doSome(),准备获得res1的锁定,但是res1的锁定被thread1线程占用，于是thread2线程进入blocked状态

volatile

synchronized所标志区块的特点:

• 互斥性：synchronized区块在一个时间点上只能有一个线程执行它

• 可见性：线程离开synchronized区块后，另一个线程面对的是上一个线程改变后的对象状态

在java中对于可见性的要求，可以使用volatile达到变量范围。
没用volatile,synchronized

public class Variable {
    static int i=0,j=0;
    static void deal(){
        i++;
        j++;
    }
    static void print(){
        System.out.println("i="+i+" j="+j);
    }
}

public class VariableTest1 extends Thread{
    @Override
    public void run(){
        while(true)
            Variable.print();
    }
}

public class VariableTest extends Thread{
    @Override
    public void run(){
        while(true)
            Variable.deal();
    }
    public static void main(String[] args){
        Thread t1=new VariableTest();
        Thread t2=new VariableTest1();
        t1.start();
        t2.start();
    }
}

...
i=638864948 j=638864993
i=638866963 j=638867006
i=638868897 j=638868941
i=638870928 j=638870974
...

可以看到j大于i,甚至可以远大于i.原因在于为了效率，线程可以快取变量的值。
t2调用Variable.print()从共享内存中取到变量i的值，并存储在自己的内存空间，如果此时cpu切换线程至t1,并不断的执行Variable.deal()多次，再切回t2,取得变量j的值，然后和i值一起输出。

如果在deal()和print()方法上标志synchronized,则t1每次调用deal()方法时，t2都必须等到t1释放锁定才能调用print()方法.t2每次调用print()方法也一样。
这种情况下，输出的i一定等于j.

在变量上声明volatile,表示变量是不稳定的，易变的。这样变量就可以在多线程情况下存取，保证了变量的可见性.换句话说，如果有线程修改了变量的值，另一个线程一定可以看到被修改的变量。
被标示为volatile的变量，不允许线程快取，变量的存取一定是在共享内存中进行。
下面将上面例子中的i,j声明为volatile.

volatile static int i=0,j=0;

...
i=34456445 j=34456448
i=34456620 j=34456623
i=34456789 j=34456791
i=34456959 j=34456961
...

可以看到没有出现j远大于i的情况,都是i略小于j.
事实上，i和j的关系可以是大于，等于，小于三种之中的任一种。

• i大于j

i已经改变，但是j仍然是上一次操作的j.

• i小于j
  
  第一次输出时，保存i,然后j++,第二次输出的是没有修改过的i和修改过的j.

• i等于j
  
  输出的都是共享内存中修改过的值.

由此可见，volatile保证的是单一变量可见性，线程对变量的存取一定是在共享内存中进行，不会在自己的内存空间中快取变量。线程对共享内存中变量的存取，另一个线程一定看得到。

等待与通知

wait(),notify(),notifyAll()是Object类中的方法，可以通过这三个方法控制线程释放对象的锁定，或者通知线程参与锁定的竞争.

线程进入synchronized区块前，要先获得指定对象的锁定。而在执行synchronized区块代码时，若调用锁定对象的wait()方法，线程会释放对象锁定，并进入对象等待集合，其他线程这时可以竞争对象锁定，取得锁定的线程可以执行synchronized区块代码。
处于等待集合中的线程不会参与竞争cpu.wait()方法可以指定等待时间，时间到之后，线程会参与竞争cpu.如果指定时间为0或没指定，则线程会一直等待，直到被中断（interrupt）或通知（notify）可以参与竞争cpu.
锁定的对象调用notify()方法，会对象等待集合中随机通知一个线程参与竞争cpu.
如果调用的是notifyAll()方法，则等待集合中的所有线程都会参与竞争cpu.