黑马程序员---Java线程与同步

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

2015.10.10
2016.3.11

目录：

1.线程
2.同步
3.常见的同步实现类

---

1.线程

进程是程序的一次动态的执行，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到消亡的过程。进程是系统对程序进行资源分配和调度的基本单位。
一个多任务程序中，每一个任务称为一个线程。一个进程拥有全部独立的变量，线程则共享变量。

进程也可以看做线程的容器。

Java中内置对多线程的支持，多线程是指同时存在几个执行体，按几条不同的执行路径进行共同工作的情况，使得应用程序能够同时处理多个任务。

操作系统使用分时管理各进程，按时间片轮流执行每个进程。Java中的多线程就是在操作系统每次分时给Java程序一个时间片的CPU时间内，在若干个独立的线程间切换。

Java应用程序总是从main()方法开始执行。执行main()创建的线程就称为主线程，如果main()中再创建一个线程就称为主线程中的线程。当main()和其中的线程全部结束后该程序才会被终止。

1.1线程的生命周期

枚举类 Thread.State：

• NEW（新建）
  使用new操作符新建一个线程。此时，程序还没有运行线程中的代码。
• Runnable（可运行）
  一旦调用了start方法，线程将处于该状态。
  因为存在系统cpu时间片的分配，所以一个线程永远不会确定是否处于运行状态
• Blocked（被阻塞）和Waiting（等待）
  当线程处于被阻塞或等待状态时，它暂时不活动。它不运行任何代码且消耗最少的资源。直到线程调度器重新激活它。
  （1）当一个线程试图获取一个内部的对象锁，而该锁被其它线程持有，则该线程进入阻塞状态。当所有其它线程释放该锁，并现场调度器允许本线程持有它的时候，该线程将变成非阻塞状态。
  （2）线程等待另一个线程通知调度器一个条件时，它自己进入等待状态。（Object.wait()或Lock或Condition）
  （3）有些方法包含超时参数。调用它们导致线程进入计时等待状态。
• Timed waiting（计时等待）

• Terminated（被终止）
  两种情况导致终止：

  • run方法正常退出而自然死亡
  • 因为一个没有捕获的异常终止了run方法而意外死亡

1.2 线程的启动
四种方法

方法一：扩展Thread类
A：扩展Thread类
B：重写run方法
C：在main()中新建线程对象
D：调用该对象的start方法

public class Test{    public static void main(String[] args){        //新建线程对象        MyThread mt=new MyThread();        //启动线程        mt.start();    }}//扩展Thread类class MyThread extends Thread{    //重写run()    public void run(){        int i=0;        while(i<100){            System.out.println("Number: "+i);            i++;        }    }}

线程类对象直接调用run方法和调用start方法的区别：
直接调用run方法只是调用普通方法，并没有启动新线程，使用Thread.start方法则是创建一个执行run方法的新线程。

方法二：实现Runnable接口
A、定义线程类实现Runnable接口
B、重写run方法
C、创建线程类对象
D、创建Thread对象并使用C步骤对象初始化
E、调用start方法启动线程

public class Test{    public static void main(String[] args){        //创建Runnable实现类对象        MyThread mt=new MyThread();        //创建Thread对象        Thread t=new Thread(mt);        //启动线程        t.start();    }}//创建自定义线程类class MyThread implements Runnable{    //重写run()    public void run(){        int i=0;        while(i<100){            System.out.println("Number: "+i);            i++;        }    }}

方法三：实现Callable接口
实现Callable接口创建有返回值的线程，还可以抛出受检查的异常。Future保存异步计算的结果。其中get方法的调用被阻塞直到计算完成。FutureTask包装器，实现了Runnable和Future接口，可以把Callable转换为Futrue和Runnable。
A：定义Callable实现类
B：创建Callable实现类对象
C：使用FutureTask包装器包装
D：启动线程
E：调用get方法获取返回值

public class Test1 {    public static void main(String[] args) throws Exception {        // 创建Callable实现类对象        Callable<Date> callable = new MyCallable();        // 使用FutureTask接受callable对象        FutureTask<Date> task = new FutureTask<Date>(callable);        // 启动线程        new Thread(task).start();        // 获取返回值        Date date = task.get();    }}// 定义Callable实现类class MyCallable implements Callable<Date> {    // 重写call()方法    public Date call() {        return new Date();    }}

方法四：使用执行器

执行器（Executor）提供了一种把任务提交和任务运行（任务的启动、线程的调度等）分离开来的机制。

如果程序中需要大量构件生命周期很短的线程，应该使用线程池。线程池中包含许多准备运行的空闲线程。将Runnable对象交给线程池，就会有一个空闲线程调用run方法，在run方法退出时，线程不会死亡，而是在池中等待下一个请求。

线程池的另一个好处是减少并发线程的数目。创建大量线程会大大降低性能甚至使虚拟机崩溃。

执行器有许多静态工厂方法来创建线程池：

• CachedThreadPool
  对于每个任务，如果有空闲线程，立即执行任务，如果没有则新建一个线程。空闲线程保留60s
• FixedThreadPool
  包含固定数量的线程。如果任务数量大于线程数量，那么多余的任务将被移到队列中，在稍后拥有空闲线程后被执行。
• SingleThreadPool
  包含一个空闲线程的线程池。按顺序执行每个被提交的任务。

线程池使用shutdown方法关闭。被关闭的执行器不再接受新的任务，所有任务完成后线程池中的线程死亡。shutdownNow方法取消未开始的任务，试图中断正在运行的线程。

A：定义Callable实现类
B：创建ExecutorService对象
C：创建Callable实现类对象
D：提交C步骤创建的对象
E：提交后的线程会自动运行
F：获取Future对象
G：获取返回的结果

import java.util.Date;import java.util.concurrent.Callable;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;//这是测试类public class Test{    public static void main(String[] args) throws Exception{        //创建一个固定大小的线程池        ExecutorService es=Executors.newFixedThreadPool(2);        //创建Callable实现类对象        MyCallable  mc1=new MyCallable();        //提交执行并获取Future对象        Future f1=es.submit(mc1);        //同上        MyCallable  mc2=new MyCallable();        Future f2=es.submit(mc2);        //获取并打印返回的结果        System.out.println(f1.get().toString());        System.out.println(f2.get().toString());        //关闭线程池        es.shutDown();    }}//定义Callable实现类class MyCallable implements Callable<Object>{    //重写call()方法    public Object call(){        return new Date();    }}

1.3 线程的中断

使用interrupt方法,调用后线程的中断状态被设置为true，每个线程都会不停的检查这个标识。

如果线程被阻塞，将无法检测中断状态。同时产生InterruptedException。

在一个阻塞的线程上调用interrupt方法，阻塞调用将会被InterruptedException异常中断。（存在不能被中断的阻塞IO调用）

线程可以把中断标识作为一个请求，并由自己决定如何响应。

    try{        //检查中断标识，如果为false，那么执行其他的工作        while(!Thread.currentThread().isInterrupted()&&other work){            //do more work        }    }catch(InterruptedException e){        //异常处理      }    finally{        //释放资源    }

注意：调用sleep方法将清除线程的中断状态，并抛出异常。

相关方法：

• static boolean interrupted()
  测试当前线程是否被中断。包含副作用，将会把当前线程的中断状态重置为false（两次调用该方法，第一次调用后它的状态为true，第二次调用将返回false）。

• boolean isInterrupted()
  测试当前线程是否被终止，无副作用。

1.4 线程属性及设置
（1）线程优先级
Java中，每个线程都有一个优先级。默认继承父线程的优先级。
当线程调度管理器有机会选择新线程时，它会优先选择具有较高优先级的线程。

setPriority

注意：优先级高度依赖系统，它被映射到系统平台上。可以使用常量来设置。

（2）守护线程
为其它线程服务的线程。

setDaemon(true)

注意：

• 守护线程不应该去访问固有资源，因为它会在任何时候发生中断。
• 守护线程的设置在线程启动之前

2.线程同步
多线程编程里面，如果有多个线程同时访问一个数据，这时候为了保护数据的完整性，就需要对操作该线程的方法或语句进行同步化。

使用情况：

• 访问的变量可能被其它线程修改
• 写入值到一个变量，而它可能会被其它线程读取。

2.1 锁对象
java.util.concurrent Lock。锁对象提供了对多线程共享资源的保护功能。只有获取到锁的线程才能访问受保护的资源。一次只能有一个线程获得锁。

具体实现类：ReentrantLock
锁对象调用lock和tryLock方法来获取锁，调用unlock方法来释放锁。

下面是一个使用锁对象保护共享资源的示例，它模拟了使用多线程售票的案例：

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Test1 {    public static void main(String[] args) throws Exception {        // 创建TicketSell实例        TicketSell runnable = new TicketSell();        // 创建线程并命名        Thread t1 = new Thread(runnable, "1号窗口");        Thread t2 = new Thread(runnable, "2号窗口");        Thread t3 = new Thread(runnable, "3号窗口");        // 启动线程        t1.start();        t2.start();        t3.start();    }}// 定义一个销售票的线程类class TicketSell implements Runnable {    // 初始有100张票,该变量将被多线程共享，所以需要对它进行加锁保护    private static int amount = 100;    // 可重入的锁对象    private Lock ticketLock = new ReentrantLock();    @Override    public void run() {        // 死循环重复售票        while (true) {            // 获取锁            ticketLock.lock();            try {                // 如果票售完，终止线程                if (amount < 1)                    break;                // 获取一张票                amount -= 1;                // 打印当前票数到控制台                System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + amount + "张票");                // 休眠当前线程10毫秒                Thread.currentThread().sleep(10);            } catch (InterruptedException e) {                System.out.println("wenti");                Thread.currentThread().interrupt();            } finally {                // finally块中保证线程能释放锁，避免死锁情况                ticketLock.unlock();            }        }    }}

2.2 条件对象

条件对象是对锁的补充，用来管理进入受保护的代码片段但还不能运行的代码。一个锁对象可以有一个或多个相关的条件对象。习惯每一个条件对象命名为可以反映它所表达的条件的名字。

使用lock.newCondition()来获取当前锁对象的条件对象。

条件对象的常用方法：

• condition.await();
  线程在此处等待进入阻塞状态。同时释放锁。
• condition.signalAll();
  重新激活在该条件对象上等待的所有线程。这些线程将从等待集中移出。
  一旦它们获取到锁，它们将从await调用返回，并从阻塞的地方继续执行。
• condition.signal();
  随机解除等待集中的一个线程的阻塞状态。危险，能造成死锁。

注意：在锁对象调用signal或signalAll返回方法后，此时的条件可能还不满足，所以仍然需要对条件进行检查。
安全代码：

while(!(ok to proceed))    condition.await();

下例中，定义了一个票池类，它包含使用锁对象和条件对象对共享数据进行保护的生产票和取出票的put和take方法，在测试用的Test1类的main方法中，分别创建了2个生产者和3个消费者，运行该示例将看到多线程下的生产者和消费者协同运作的情景：

import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Test1 {    public static void main(String[] args) throws Exception {        // 创建TicketPoll实例        TicketPoll ticketPoll = new TicketPoll();        // 使用匿名内部类实例化一个Runnable对象，它将用于创建生产者线程        Runnable productor = new Runnable() {            @Override            public void run() {                while (true) {                    try {                        // 生产票                        ticketPoll.put();                    } catch (InterruptedException e) {                        Thread.currentThread().interrupt();                    }                }            }        };        // 使用匿名内部类实例化一个Runnable对象，它将用于创建消费窗口线程        Runnable customer = new Runnable() {            @Override            public void run() {                while (true) {                    try {                        // 消费票                        ticketPoll.take();                    } catch (InterruptedException e) {                        Thread.currentThread().interrupt();                    }                }            }        };        // 创建2个生产者线程        Thread p1 = new Thread(productor, "1号生产者");        Thread p2 = new Thread(productor, "2号生产者");        // 创建3个售票窗口线程        Thread s1 = new Thread(customer, "1号售票窗口");        Thread s2 = new Thread(customer, "2号售票窗口");        Thread s3 = new Thread(customer, "2号售票窗口");        // 启动线程        p1.start();        p2.start();        s1.start();        s2.start();        s3.start();    }}// 定义一个票池类class TicketPoll {    // 初始有0张票,该变量将被多线程共享，所以需要对它进行加锁保护    private static int amount = 0;    // 可重入的锁对象    private final Lock lock = new ReentrantLock();    // 条件对象    private final Condition isEmpty = lock.newCondition();    private final Condition isFull = lock.newCondition();        // 向票池中放入票，由生产者线程调用    public void put() throws InterruptedException {        // 获取锁对象        lock.lock();        try {            // 当票数超过100张，那么使用条件对象的await方法使当前生产线程等待，注意条件对象即使在方法返回后也必须重新判断            while (amount > 100) {                isFull.await();            }            // 如果没有超过上限，那么放入一张票            amount += 1;            // 打印当前状态            System.out.println(Thread.currentThread().getName() + "放入出一张票，还剩" + amount + "张票");            // 唤醒isEmpty条件对象等待的线程            isEmpty.signalAll();        } finally {            // 保证释放锁            lock.unlock();        }    }    // 从票池中取出票，由售票窗口调用    public void take() throws InterruptedException {        // 获取锁对象        lock.lock();        try {            // 当票数为空，那么使用条件对象的await方法使当前线程等待，条件对象即使在方法返回后也必须重新判断            while (amount < 1) {                isEmpty.await();            }            // 如果仍然有票，那么取出一张票            amount -= 1;            // 打印当前状态            System.out.println(Thread.currentThread().getName() + "取出一张票，还剩" + amount + "张票");            // 唤醒isFull条件对象等待的线程            isFull.signalAll();        } finally {            // 保证释放锁            lock.unlock();        }    }}

2.3 synchronized 关键字

Java语言的内部机制中，每个对象都有一个内部锁（理解为Lock锁）。如果一个方法使用该关键字声明，那么对象的锁将保护整个方法，也就是只有获取到内部锁才能进入该方法。

例如：

    public synchronized void method() {        // code    }

就相当于：

    public void method() {        this.intrinsiclock.lock();        try {            // code        } finally {            this.intrinsiclock..unlock();        }    }

内部对象锁只有一个相关条件。wait方法添加一个线程到等待集，notifyAll/notify方法解除等待线程的阻塞状态。即调用this.wait和this.notifyAll相当于：
condition.await()和condition.signalAll()

注意：Object的wait，notify，notifyAll为final方法，Condition的方法名必须不同，才能与Object的方法不冲突。

使用synchronized声明同步代码块：

synchronized(obj){    do something}

obj为任意对象，由于每个Java对象都含有一个隐形的内部锁，所以任意的Object对象都可以作为同步代码块的锁对象。

与锁对象和条件相比：

• 不能中断一个正在试图获得锁的线程。
  例如不能使用tryLock()超时方法，在规定时限后则放弃
• 试图获取锁时不能超时
• 只有一个条件对象

2.4 死锁

死锁是指当一个线程一直持有锁对象后，其它线程等待获取该锁对象的状态。

死锁产生的条件：
（1）互斥条件。任务使用的资源中至少有一个是不能共享的。
（2）持有等待。至少有一个任务它必须持有一个资源且正在等待获取另一个资源。
（3）资源不能被任务抢占。也就是说线程不会跑到别的线程中抢资源，只能由持有者自己释放。
（4）必须有循环等待。这时候一个任务等待其他任务的资源，而后者又在等待其它的资源，如此循环直到最后一个任务在等待第一任务的资源。

例如：
下例中，两个锁对象lock1,lock2是不能共享的资源，这是互斥条件；当一个线程进入同步代码块后，即持有该对象锁，其他线程不能强行抢占他持有的锁，这是资源不可抢占；run方法中，使用了同步代码块的嵌套，当上例中的两个线程同时进入外层同步代码块时，分别持有lock1和lock2锁，但又分别等待对方的lock2和lock1锁，这样陷入了持有等待和循环等待的状态。

public class Test {    public static void main(String[] args) throws Exception {        new Thread(new Demo(true)).start();        ;        new Thread(new Demo(false)).start();        ;    }}//创建自定义实现Runnable的类class Demo implements Runnable {    boolean flag;    Object lock1=new Object();    Object lock2=new Object();    protected Demo(boolean flag) {        super();        this.flag = flag;    }    public void run() {        if (flag) {            synchronized (lock1) {                System.out.println("wait lock2");                synchronized (lock2) {                    System.out.println("inter");                }            }        } else {            synchronized (lock2) {                System.out.println("wait lock1");                synchronized (lock1) {                    System.out.println("inter");                }            }        }    }}

死锁的解决，上面的死锁产生的四个条件中的任何一个条件被破坏，死锁就不会产生。
对于上面的死锁示例中，run方法中通过boolean标识故意引导两个线程分别持有对方正在等待的锁，我们可以破坏这个循环等待条件来取消死锁的发生。只需要这样修改run方法即可：

public void run() {        //线程将按顺序持有和释放锁，而不会陷入循环等待。        synchronized (lock1) {            System.out.println("wait lock2");            synchronized (lock2) {                System.out.println("inter");            }        }}

3.常见的同步实现类

遇到同步情况的优先选择是使用Java中的同步机制，然后才考虑自己来解决同步问题。

3.1 阻塞队列

阻塞队列（BlockingQueue）与前面讨论的普通队列相比，除了线程安全外，还增加了两个阻塞方法：put和take方法，在调用这两个方法时如果不满足条件线程将被阻塞。

阻塞队列中有众多的添加和获取元素的方法，在选择的时候需要根据实际情况来考虑。

阻塞队列不允许null元素，因为poll方法在失败时会返回null。阻塞队列实现主要用于生产者-使用者队列。

示例：下面的示例中使用了ArrayBlockingQueue来演示一个线程安全的票池（生产者-使用者队列）。

class TicketPoll {    // 设计一个容量为100的票池，由于ArrayBlockingQueue是一个同步安全的实现，所以即使多线程访问它我们也无需再外部实现同步机制    final BlockingQueue<String> poll = new ArrayBlockingQueue<String>(100);    // 取票的方法，当票数小于0时，take方法陷入阻塞    public void sellTicket() throws InterruptedException {        poll.take();    }    // 放票的方法，当票数达到上限时，put方法陷入阻塞    public void putTicket() throws InterruptedException {        poll.put("a Ticket");    }}

（1）ArrayBlockingQueue

一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部是在队列中存在时间最长的元素，队列的尾部 是在队列中存在时间最短的元素。
此队列可以创建公平者模式，即队列将优先选择等待时间长的元素放置到队列的头部，但这会降低性能。

ArrayBlockingQueue方法使用示例：

// 创建一个容量为5的阻塞队列BlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);// 使用put方法放置元素,超出容量时线程被阻塞queue.put("java");queue.put("and");queue.put("android");queue.put("programmer");queue.put("ios");// 此时队列已满，再次调用put方法将阻塞当前线程// queue.put("last");// 使用offer方法，在方法参数中设置了5秒钟的延迟，超时后将返回falseboolean flag = queue.offer("last", 2, TimeUnit.SECONDS);// falsefor (int i = 0; i < 5; i++) {    // 取出所有元素    queue.take();}// 当队列为空时，take方法将进入阻塞状态// queue.take();// poll方法获取并移除队列的头元素，超时后返回null，由于此时队列为空，所以element=nullString element = queue.poll(2, TimeUnit.SECONDS);

（2）LinkedBlockingQueue

底层为链表的阻塞队列，它是无界的。在并发中可能性能较低。为了防止内存过度膨胀，可以设置容量。

（3）PriorityBlockingQueue

带有优先级的队列，元素按照优先级被移除。该队列没有容量上限。
同PriorityQueue相同，优先级队列可以使用自然排序或者比较器排序。这取决于具体的构造方法。

（4）TransferQueue （接口，since 1.7）

允许生产者线程等待，直到消费者准备就绪可以接收一个元素。
q.transfer(item);
该方法一直阻塞直到另一个线程将item删除。
也就是该方法不是在队列满才阻塞，而是每生产一个元素，在该元素被消费之前一直阻塞。

具体实现类：LinkedTransferQueue

3.2 ConcurrentHashMap

3.3 较早的同步集合

Vector和Hashtable