黑马程序员---第四讲 多线程的应用（2）

第四讲 多线程的应用（2）

一、线程安全问题的另一解决方案

前面我们已经知道，同步代码块的锁是任意对象，同步方法的锁是this对象，静态方法的锁是类的字节码文件对象。但是前面的方法不够明确，我们很难看到代码是在哪锁的，又是在哪解锁的。为了更清晰的表达在哪里加锁，在哪里解锁，JDK5中提供了Lock锁。
代码实现如下：

package cn.itcast_01;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class MyLock implements Runnable {    private int ticket = 100;    private Lock lock = new ReentrantLock();    @Override    public void run() {        while (true) {            // 加锁            lock.lock();            if (ticket > 0) {                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName()                            + "正在出售第" + (ticket--) + "张票");            }            // 释放锁            lock.unlock();        }    }}

package cn.itcast_01;public class MyLockDemo {    public static void main(String[] args) {        MyLock ml=new MyLock();        Thread t1=new Thread(ml,"窗口一");        Thread t2=new Thread(ml,"窗口二");        Thread t3=new Thread(ml,"窗口三");        t1.start();        t2.start();        t3.start();    }}

这样写代码有一个这样的问题，一旦加锁和释放锁之间的代码出现问题，程序就会被锁在这里，无法执行下面的代码，所以加锁的部分我们通常做如下改进。这样无论中间的代码出现什么问题，我都会释放锁。

package cn.itcast_01;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class MyLock implements Runnable {    private int ticket = 100;    private Lock lock = new ReentrantLock();    @Override    public void run() {        while (true) {            try {                // 加锁                lock.lock();                if (ticket > 0) {                    try {                        Thread.sleep(100);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName()                            + "正在出售第" + (ticket--) + "张票");                }            }            finally {                // 释放锁                lock.unlock();            }        }    }}

---

二、死锁问题

我们知道同步线程的执行效率较低，因为每个线程执行前都要先判断锁对象，但是这个不足我们是可以接受的，因为他毕竟解决了线程安全的问题。但是另外一个缺陷是我们接受不了的，就是“死锁”问题，通俗的理解就是钥匙卡在锁里了，谁也打不开锁了，谁也进不了家了。那么究竟什么是“死锁”呢？死锁是指两个或者两个以上的线程在执行过程中，因争夺资源产生的一种相互等待的现象。如果出现同步嵌套，就容易出现“死锁”问题。让我们来看一段代码理解“死锁”出现的情形。

package cn.itcast_02;public class MyLock {    public static final Object objA=new Object();    public static final Object objB=new Object();}

package cn.itcast_02;public class DieLock extends Thread {    private boolean flag = false;    public DieLock(boolean flag) {        this.flag = flag;    }    @Override    public void run() {        if (flag) {            synchronized (MyLock.objA) {                System.out.println("if objA");                synchronized (MyLock.objB) {                    System.out.println("if objB");                }            }        } else {            synchronized (MyLock.objB) {                System.out.println("else objB");                synchronized (MyLock.objA) {                    System.out.println("else objA");                }            }        }    }}

package cn.itcast_02;public class DieLockDemo {    public static void main(String[] args) {        DieLock dl1=new DieLock(true);        DieLock dl2=new DieLock(false);        dl1.start();        dl2.start();    }}

---

三、线程间的通信

1.多线程的两种模型

解决上述的死锁问题，就要用到线程间的通信。为了更透彻的理解死锁问题的解决方案，在这里我们先不谈线程通信怎么解决该问题，我们先谈谈什么是线程通信。
前面的售票的例子我们可以用下面的模型来表示，100张票是死的，三个窗口来卖。

但是生活中的很多现象并不是这样的，例如卖煎饼我们可以用下面的模型来表示。卖煎饼的前端是买煎饼的也就是消费者，而卖煎饼的后边是后端也就是生产者。消费者和生产者在交易过程中是会沟通的，如果还有煎饼可卖，那么生产者就等着，并叫卖让消费者来买；反之，如果没有煎饼了，消费者会等着，并告知生产者需要生产煎饼了。

2.设置、获取线程模型的实现

上面的例子就可以说明线程通信问题，即不同种类的线程间（生产者或消费者）针对同一资源（煎饼）的操作。生产者可以称为设置线程，消费者可以称为获取线程。下面用代码实现上述模型。

package cn.itcast_03;public class Student {    String name;    int age;}

package cn.itcast_03;public class SetThread implements Runnable {    @Override    public void run() {        Student s=new Student();        s.name="刘亦菲";        s.age=27;    }}

package cn.itcast_03;public class GetThread implements Runnable {    @Override    public void run() {        Student s=new Student();        System.out.println(s.name+"---"+s.age);    }}

package cn.itcast_03;public class StudentThread {    public static void main(String[] args) {        SetThread st=new SetThread();        GetThread gt=new GetThread();        Thread t1=new Thread(st);        Thread t2=new Thread(gt);        t1.start();        t2.start();    }}

通过执行上述代码发现，并没有出现我们预期的结果，有设置有获取。通过分析发现，原因是两个线程中的对象不是同一个对象，这样就不符合线程通信的“针对同一资源的操作”。举个简单的例子，买煎饼的和卖肉夹馍的在买卖过程中会有交流吗？答案是显而易见的。
那么我们就要对上述代码进行改进，改进的思路很简单，在测试类中新建对象，把该对象最为参数传递到线程中，就能保证操作的是同一个资源。但是这时候要注意，线程中必须存在该种构造方法。改进代码如下。

package cn.itcast_04;public class SetThread implements Runnable {    private Student s;    private int i = 0;    public SetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            if (i % 2 == 0) {                s.name = "刘亦菲";                s.age = 27;            } else {                s.name = "宋承宪";                s.age = 37;            }            i++;        }    }}

package cn.itcast_04;public class GetThread implements Runnable {    private Student s;    public GetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            System.out.println(s.name + "---" + s.age);        }    }}

package cn.itcast_04;public class StudentThread {    public static void main(String[] args) {        Student s=new Student();        SetThread st=new SetThread(s);        GetThread gt=new GetThread(s);        Thread t1=new Thread(st);        Thread t2=new Thread(gt);        t1.start();        t2.start();    }}

3.线程安全问题的解决

通过运行上述代码，很容易就发现代码存在安全问题。主要有两个问题：一是一个数据出现多次，二是姓名和年龄不匹配。经过分析可知，出现第一个问题的原因是CPU一点点时间片的执行权，就够执行多次循环。出现第二个问题的原因是线程运行的随机性。
通过上一讲我们可以知道，解决安全问题可以通过同步来实现，也就是给线程加锁。解决安全问题的代码实现如下。

package cn.itcast_05;public class SetThread implements Runnable {    private Student s;    private int i = 0;    public SetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                if (i % 2 == 0) {                    s.name = "刘亦菲";                    s.age = 27;                } else {                    s.name = "宋承宪";                    s.age = 37;                }            }            i++;        }    }}

package cn.itcast_05;public class GetThread implements Runnable {    private Student s;    public GetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                System.out.println(s.name + "---" + s.age);            }        }    }}

4.线程通信问题的实现

通过上述改进，线程的安全问题得到了解决。但是一个数据还是会出现多次，这显然不是我们想要的。如果两个线程之间能建立起联系就好了，假设设置线程先抢到CPU的执行权，他首先检查是否有数据，如果有数据设置线程就等待，并告诉获取线程可以获取值了，如果没有数据他就完成赋值操作，并告诉获取线程可以可以获取值了，以此类推。这就是所谓的等待唤醒机制，下面我们就用等待唤醒机制来修改之前的代码。
这里存在这样一个问题，wait（）方法和notify（）方法为什么会是Object类中的方法呢？通过查API我们发现notify（）方法的描述是这样的，“唤醒在此对象监视器上等待的单个线程”，这里的此对象监视器也就是锁对象，所以wait（）方法和notify（）都是要通过锁对象来调用的，而锁对象是任意对象，所以决定上述两个方法都是Object类的方法。

package cn.itcast_07;public class Student {    String name;    int age;    boolean flag;}

package cn.itcast_07;public class SetThread implements Runnable {    private Student s;    private int i = 0;    public SetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                if (s.flag) {                    try {                        s.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                if (i % 2 == 0) {                    s.name = "刘亦菲";                    s.age = 27;                } else {                    s.name = "宋承宪";                    s.age = 37;                }                i++;                // 修改标记                s.flag = true;                // 唤醒线程                s.notify();            }        }    }}

package cn.itcast_07;public class GetThread implements Runnable {    private Student s;    public GetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                if(!s.flag){                    try {                        s.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                System.out.println(s.name + "---" + s.age);                //修改标记                s.flag=false;                //唤醒线程                s.notify();            }        }    }}

5.代码优化

下面的代码优化主要是优化了以下两项：一、将学生类的成员变量私有化；二、将设置和获取封装到了方法中，并在方法中实现同步。

package cn.itcast_08;public class Student {    private String name;    private int age;    private boolean flag;    public synchronized void set(String name, int age) {        if (this.flag) {            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        this.name = name;        this.age = age;        // 修改标记        this.flag = true;        // 唤醒线程        this.notify();    }    public synchronized void get() {        if (!this.flag) {            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        System.out.println(this.name + "----" + this.age);        // 修改标记        this.flag = false;        // 唤醒线程        this.notify();    }}

package cn.itcast_08;public class SetThread implements Runnable {    private Student s;    private int i = 0;    public SetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            if (i % 2 == 0) {                s.set("刘亦菲", 27);            } else {                s.set("宋承宪", 30);            }            i++;        }    }}

package cn.itcast_08;public class GetThread implements Runnable {    private Student s;    public GetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            s.get();        }    }}

6.线程状态转化

四、线程组

线程组可以实现对线程的批量设置，比如将线程添加到线程组、获取线程组名称、设置线程组为后台线程、设置线程组最大优先级等，部分功能实现如下

package cn.itcast_09;public class Group implements Runnable {    @Override    public void run() {        for(int i=1;i<=100;i++){            System.out.println(Thread.currentThread().getName()+":"+i);        }    }}

package cn.itcast_09;public class GroupDemo {    public static void main(String[] args) {        //method1();        method2();    }    private static void method2() {        Group g = new Group();        ThreadGroup tg = new ThreadGroup("线程组A");        Thread t1 = new Thread(tg,g,"刘亦菲");        Thread t2 = new Thread(tg,g,"宋承宪");        t1.start();        t2.start();        System.out.println(t1.getThreadGroup().getName());        System.out.println(t2.getThreadGroup().getName());    }    private static void method1() {        Group g = new Group();        Thread t1 = new Thread(g);        Thread t2 = new Thread(g);        /*         * t1.start(); t2.start();         */        ThreadGroup tg1 = t1.getThreadGroup();        ThreadGroup tg2 = t2.getThreadGroup();        System.out.println(tg1.getName());        System.out.println(tg2.getName());        System.out.println(Thread.currentThread().getThreadGroup().getName());    }}

---

五、线程池

程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
线程池中的每一个线程代码结束后，并不会死亡，而是再次回到了线程池成为空闲状态，等待下一个对象来使用。从JDK5开始Java内置支持线程池，提供了Executors类来产生线程池，有如下几个方法：
- public static ExecutorService newCachedThreaPool()
- public static ExecutorService newFixedThreaPool(int nThreads)
- public static ExecutorService newSingleThreaExecutor()

这些方法的返回值是ExecutorService类的对象，该对象就表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程，它提供了如下方法：
- Future

1、实现Runnable接口代码实现如下

package cn.itcast_10;public class MyRunnable implements Runnable {    @Override    public void run() {        for(int i = 1;i<=100;i++){            System.out.println(Thread.currentThread().getName()+":"+i);        }    }}

package cn.itcast_10;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ExecutorDemo {    public static void main(String[] args) {        ExecutorService pool = Executors.newFixedThreadPool(2);        pool.submit(new MyRunnable());        pool.submit(new MyRunnable());        pool.shutdown();    }}

2、实现Callable接口代码实现如下

package cn.itcast_11;import java.util.concurrent.Callable;public class MyCallable implements Callable<Integer> {    private int number;    public MyCallable(int number){        this.number=number;    }    @Override    public Integer call() throws Exception {        int sum=0;        for (int i = 1; i <= number; i++) {            sum+=i;        }        return sum;    }}

package cn.itcast_11;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class CallableDemo {    public static void main(String[] args) throws InterruptedException, ExecutionException {        ExecutorService pool = Executors.newFixedThreadPool(2);        Future<Integer> f1 = pool.submit(new MyCallable(100));        Future<Integer> f2 = pool.submit(new MyCallable(200));        Integer num1=f1.get();        Integer num2=f2.get();        System.out.println(num1);        System.out.println(num2);        pool.shutdown();    }}

---

六、匿名内部类开线程

在我们实际开发中有时仅仅是想开一个线程，不管用之前的继承Thread类还是实现Runnable接口都显得有些麻烦，这时便可以使用匿名内部类来开启线程。代码实现如下

package cn.itcast_12;public class ThreadDemo {    public static void main(String[] args) {        new Thread() {            public void run() {                for (int i = 1; i <= 100; i++) {                    System.out.println(Thread.currentThread().getName() + ":"                            + i);                }            }        }.start();        new Thread(new Runnable() {            @Override            public void run() {                for (int i = 1; i <= 100; i++) {                    System.out.println("重写接口" + ":"                            + i);                }            }        }) {        }.start();        /*new Thread(new Runnable() {            @Override            public void run() {                for (int i = 1; i <= 100; i++) {                    System.out.println("重写Runnable" + ":" + i);                }            }        }) {            public void run() {                for (int i = 1; i <= 100; i++) {                    System.out.println("内部类的方法" + ":" + i);                }            }        }.start();*/    }}