java学习笔记（二）多线程

知识点概要：

1、线程的生命周期：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。

2、启动线程调用的是start()方法而不是run()方法。如果直接调用run()方法，则run()方法会立即执行，而且在run()方法返回之前其他线程无法并发执行，也就是说把线程对象当做一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。

3、线程死亡（线程结束的三种方式）：

     a、run()或者call()方法执行完成，线程正常结束；

     b、线程抛出一个未捕获的Exception获Error；

     c、直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用。

4、isAlive()方法判断线程的状态，就绪、运行、阻塞3中状态时，该方法返回true；当线程处于新建、死亡2中状态时，该方法返回false;

5、不可以对已经死亡的线程调用start()方法。

6、join()方法。让一个线程等待另一个线程执行完成的方法。在某个程序执行流中调用其他线程的join()方法，调用线程被阻塞，知道被调用线程执行完毕。

7、后台线程。前台线程都死亡了，后台线程会自动死亡。

     isDaemon()方法用于判断指定线程是否是后台线程。

     setDaemon将指定线程设置为后台线程，必须在调用start()方法之前调用。

8、sleep()方法。让当前线程暂停一段时间，并进入阻塞状态。

9、yield()方法。让当前线程暂停，但不会阻塞该线程，它只是将该线程转入就绪状态。当某个线程调用yield()方法暂停之后，只有优先级与当前线程优先级相同或高的、处于就绪状态的线程才会获得执行机会。

10、synchronized。用来修饰代码块或者方法，不能用来修饰属性跟构造器。

释放同步锁的情况：

     a、当前线程的同步方法、同步代码块执行结束，当前线程即释放同步监视器；

     b、当线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行，当前线程将会释放同步监视器；

     c、当线程在同步代码块、同步方法中出现了未处理的Error获Exception，导致了该代码块、该方法异常结束时会释放同步监视器；

     d、当线程执行同步代码块或同步方法时，程序执行了同步监视器对象的wait()方法，则当前线程暂停，并释放同步监视器。

不会释放同步锁的情况：

     a、线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法来暂停当前线程的执行，当前线程不会释放同步监视器；

     b、线程执行同步代码块时，其他线程调用了该线程的suspend方法将该线程挂起，该线程不会释放同步监视器。

11、Lock。效果跟synchronized类似，但是比synchronized具有更广泛的锁定操作，一般用ReentrantLock(可重入锁)。

12、synchronized跟ReentrantLock区别：

1)、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候。

     线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，

     如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断

     如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情

    ReentrantLock获取锁定与三种方式：

    a)  lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁

    b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；

    c) tryLock(long timeout,TimeUnit unit)，   如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；

    d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断。

2)、 synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会 自动释放锁定，但是使用Lock则不行， lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中。

3)、在资源 竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；

一、并行跟并发的区别

并行指在同一时刻，有多条指令在多个处理器上同时执行；并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时进行的效果。对于一个CPU而言，他在某个时间点上只能执行一个程序，也就是说只能运行一个进程，CPU不断地在这些进程之间轮换执行。但是我们感觉不到任何中断现象，原因是CPU的执行速度相对我们的感觉太快了。

二、两种方式创建线程

创建线程有两种方式，一是继承Thread类，二是实现Runnable接口。如果采用Thread方式，其优势是访问当前线程时，无须使用Thread.currentThread()方法，直接使用this即可获得当前线程；劣势是其已经继承了Thread类，所以不能再继承其他父类。如果采用Runnable方式，其优势是实现Runnable接口的同时，还可以继承其他类，并且在这种方式相爱可以多个线程共享同一个target对象；劣势是访问当前线程，必须使用Thread.currentThread()方法。注：采用Runnable方式创建的对象只能作为线程对象的target。

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午9:54
 * Thread/Runnable两种方式创建进程
 */
public class ThreadAndRunnable {
    public static void main(String[] args) {
        ByThread thread = new ByThread();
        thread.start();
        //采用Runnable方式创建的对象只能作为线程对象的target。
        ByRunnable runnable = new ByRunnable();
        Thread t = new Thread(runnable);
        t.start();
    }
}

class ByThread extends Thread {
    public void run() {
        System.out.println(this.getName());
    }
}

class ByRunnable implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

三、IllegalThreadStateException

测试某条线程是否已经死亡，可以调用线程对象的isAlive()方法，当线程处于就绪、运行、阻塞三种状态是，该方法将返回true；当线程处于新建、死亡两种状态时，该方法将返回false。警告：1、不要对一个线程调用两次start()方法；2、不要对一个已经死亡的线程调用start()方式使其重新启动。这两种做法都会导致IllegalThreadStateException异常。

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午10:11
 * 两种错误的做法导致IllegalThreadStateException
 */
public class ThreadException extends Thread {
    public void run() {
        System.out.println("123");
    }

    public static void main(String[] args) {
        ThreadException thread1 = new ThreadException();
        ThreadException thread2 = new ThreadException();

        //两次调用start()方法
        thread1.start();
        thread1.start();

        //试图对已经死亡的线程调用start()方法使其启动
        if(!thread2.isAlive()) {
            thread2.start();
        }
    }
}

四、join方法的作用

join()方法的作用是为了保证某个线程执行完毕后再往下执行其他线程。join(long millis)方法表示等待被join的线程的时间最长为millis毫秒。如果在millis毫秒内，被join的线程还没有执行结束则不再等待。

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午10:26
 * join方法的作用
 */
public class JoinThread extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName());
        }
    }

    public static void main(String[] args) throws Exception {
        JoinThread thread1 = new JoinThread();
        thread1.setName("thread1");
        JoinThread thread2 = new JoinThread();
        thread2.setName("thread2");
        thread1.start();
        //保证线程thread1执行完毕后再往下继续执行
        thread1.join();
        thread2.start();
    }
}

如果没有添加join()来保证thrread1已经执行完毕的话，CPU会不停的无规律的轮换执行，所以会出现thread1、thread2交替执行的结果。如图：

五、sleep()与yield()的区别

1、sleep()方法暂停当前线程后，会给其他线程执行机会，不需要理会其他线程的优先级。但是yield方法指挥给优先级相同，或者优先级更高的线程执行机会。

2、sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就续状态。二yield不会将线程转入阻塞状态，他只是强制当前线程进入就绪状态。因此完全有可能某个线程嗲用yield()方法暂停之后，立即再次获得处理器资源被执行。

3、sleep()方法声明抛出了InterruptedException异常，而yield没有。

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午11:21
 */
public class SleepThread extends Thread {
    public SleepThread(String name) {
        super(name);
    }

    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(this.getName() + i);
            if(i == 3) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SleepThread sleep1 = new SleepThread("Sleep-高优先级");
        SleepThread sleep2 = new SleepThread("Sleep-低优先级");
        sleep1.setPriority(Thread.MAX_PRIORITY);
        sleep2.setPriority(Thread.MIN_PRIORITY);
        sleep1.start();
        sleep2.start();
    }
}

运行效果如图，可以看出sleep方法对不会理会优先级的高低。

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午11:25
 * To change this template use File | Settings | File Templates.
 */
public class YieldThread extends Thread {
    public YieldThread(String name) {
        super(name);
    }

    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(this.getName() + i);
            if(i == 3) {
                Thread.yield();
            }
        }
    }

    public static void main(String[] args) {
        YieldThreadyield1 = new YieldThread("Yield-高优先级");
        YieldThreadyield2 = new YieldThread("Yield-低优先级");
        //设置优先级
        yield1.setPriority(Thread.MAX_PRIORITY);
        yield2.setPriority(Thread.MIN_PRIORITY);
        //启动两个并发线程
        yield1.start();
        yield2.start();
    }
}

运行效果如图，调用yield()方法后，执行机会会让给同级 或更高级的线程。

六、后台线程

<strong>package cn.com.postel.wbb.crazyJava.thread;

</strong>public class DaemonThread extends Thread {
       public void run() {
             for (int i = 0; i < 1000; i++) {
                  System. out.println(Thread.currentThread().getName() + " " + i);
            }
      }

       public static void main(String[] args) {
            DaemonThread dt = new DaemonThread();
            dt.setDaemon( true);
            dt.start();
             for (int i = 0; i < 10; i++) {
                  System. out.println(Thread.currentThread().getName() + " " + i);
            }
             // 到此，前台线程执行结束，后台线程也会结束
      }
}<strong>
</strong>

七、线程同步synchronized、Lock。

线程同步可以使用synchronized关键字来控制，也可以使用Lock对象来进行控制，在使用Lock对象来控制线程同步的时候最后一定要释放锁。

package cn.com.postel.wbb.crazyJava.thread;

import java.util.concurrent.locks.ReentrantLock;

public class Account {
       private String accountNo ;
       private double balance ;
       private final ReentrantLock lock = new ReentrantLock();

       public Account() {
      }

       public Account(String accountNo, double balance) {
             this.accountNo = accountNo;
             this.balance = balance;
      }

       public int hashCode() {
             return accountNo .hashCode();
      }

       public boolean equals(Object obj) {
             if (this == obj) {
                   return true ;
            }
             if (obj != null && obj.getClass() == Account. class) {
                  Account target = (Account) obj;
                   return target.getAccountNo().equals(accountNo );
            }
             return false ;
      }

       public void draw(double drawAmount) {
             try {
                   lock.lock();
                   if (balance >= drawAmount) {
                        System. out.println(Thread.currentThread().getName()
                                    + "取钱成功，吐出钞票：" + drawAmount);
                         try {
                              Thread. sleep(1);
                        } catch (InterruptedException e) {
                              e.printStackTrace();
                        }
                         // 修改余额
                         balance = balance - drawAmount;
                        System. out.println("\t余额为：" + balance);
                  } else {
                        System. out.println(Thread.currentThread().getName()
                                    + "余额不足，取钱失败！" );
                  }
            } catch (Exception e) {
                  e.printStackTrace();
            } finally {
                  lock.unlock();
            }
      }

       public String getAccountNo() {
             return accountNo ;
      }

       public void setAccountNo(String accountNo) {
             this.accountNo = accountNo;
      }

       public double getBalance() {
             return balance ;
      }
}