第十六章.多线程

线程的创建和启动：

　　1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体

　　2.创建Thread子类的实例，即创建了线程的对象

　　3.调用线程对象的start()方法来启动该线程

public class FirstThread extends Thread{
    private int i;
    //重写run()方法，run()方法的方法体就是线程的执行体
    public void run(){
        for(; i < 100; i++){
            //当线程类继承Thread类时，直接使用this即可获取当前线程
            //Thread对象的getName9)返回当前线程的名字
            //因此可以直接调用getName()方法返回当前线程的名字
            System.out.println(getName() + " " + i);
        }
    }
    
    public static void main(String[] args){
        for(int i = 0; i < 100; i++){
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if(i == 20){
                //创建并启动第一个线程
                new FirstThread().start();
                //创建并启动第二个线程
                new FirstThread().start();
            }
        }
    }
}

　　使用继承Thread类的方法来创建线程类时，多个线程之间无法共享线程类的实例变量。

实现Runnable接口创建线程类：

　　1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法体同样是该线程的线程执行体。

　　2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

　　//创建Runnable实现类的对象

　　SecondThread st = new SecondThread();

　　//以Runnable实现类的对象作为Thread的target来创建Thread对象，即线程对象

　　new Thread(st);

　　也可以在创建Thread线程的时候为该Thread对象指定一个名字：

　　new Thread(st, "新线程1");

　　Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其

　　　target的run()方法。

　　3.调用线程对象的start()方法来启动该线程

public class SecondThread implements Runnable{
    private int i;
    //run()方法同样是线程执行体
    public void run(){
        for(; i < 100; i++){
            //当线程类实现Runnable接口时
            //若想获取当前线程，只能用Thread.currentThread()方法
            //因此可以直接调用getName()方法返回当前线程的名字
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
    
    public static void main(String[] args){
        for(int i = 0; i < 100; i++){
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if(i == 20){
                SecondThread st = new SecondThread();
                //通过new Thread(target, name)方法创建新线程
                new Thread(st, "新线程1").start();
                new Thread(st, "新线程2").start();
            }
        }
    }
}

　　　　通过实现Runnable接口来获得当前线程对象，必须使用Thread.currentThread()方法。

　　　　Runnable接口只包含一个抽象方法，所以是函数式接口；Callable接口也是函数式接口。

　　　　从上面运行结果可以看出，新线程1和新线程2的两个i值没有重复，这说明采用Runnable接口的方式创建的多线程可以共享线程类的实例变量。这是因为在这种方式下，程

　　　　　序所创建额Runnable对象只是线程的target，而多个线程可以共享同一个target，所以多线程可以共享同一个线程的target类的实例变量。

使用Callable和Future创建线程：

　　Callable接口提供了一个call()方法，可以作为线程执行体，但call()方法比run()方法更强大：

　　　　1.call()方法有返回值

　　　　2.call()方法可以声明抛出异常

　　可以完全提供一个Callable对象作为Thread的target，而该线程的线程执行体就是该Callable对象的call()方法

　　Java5提供了Future接口来代表Callable接口里call()方法的返回值，并为接口Future提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口——可

　　　以作为Thread类的target。

　　Callable接口有泛型限制，Callable接口里的泛型形参类型与call()方法返回值类型相同。且Callable接口是函数式接口。

　　创建并启动有返回值的线程的步骤如下：

　　　　1.创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法由返回值，在创建Callable实现类的实例。

　　　　2.使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值

　　　　3.使用FutureTask对象作为Thread对象的target创建并启动新线程

　　　　4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

import java.util.concurrent.FutureTask;
import java.util.concurrent.Callable;

public class ThirdThread{
    public static void main(String[] args){
        //先使用Lambda表达式创建Callable<Integer>对象
        //使用FutureTask来包装Callable对象
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>) () -> {
            int i = 0;
            for( ; i < 100; i++){
                System.out.println(Thread.currentThread().getName() + " 的循环变量i的值：" + i);
            }
            //call()方法可以有返回值
            return i;
        });
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值：" + i);
            if(i == 20){
                //实质还是以Callable对象来创建并启动线程
                new Thread(task, "有返回值的线程").start();
            }
        }
        
        try{
            //获取线程返回值
            System.out.println("子线程的返回值：" + task.get());
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }
}

public class InvokeRun extends Thread{
    private int i;
    //重写run()方法，run()方法的方法体就是线程执行体
    public void run(){
        for( ; i < 100; i++){
            //直接调用run()方法时，Thread的this.getName()返回的是该对象的名字
            //而不是当前线程的名字
            //使用Thread.currentThread().getName()总是获取当前线程的名字
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
    
    public static void main(String[] args){
        for(int i = 0; i < 100; i++){
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if( i == 20){
                //直接调用线程对象的run()方法
                //系统会把线程对象当成普通对象，把run()方法当成普通方法
                //所以下面两行代码并不会启动两个线程，而是一次执行两个run()方法
                new InvokeRun().run();
                new InvokeRun().run();
            }
        }
    }
}

public class StartDead extends Thread{
    private int i;
    //重写run()方法，run()方法的方法体就是线程执行体
    public void run(){
        for( ; i < 100; i++){
            System.out.println(getName() + " " + i);
        }
    }
    
    public static void main(String[] args){
        //创建线程对象
        StartDead sd = new StartDead();
        for(int i = 0; i < 300; i++){
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if( i == 20){
                //启动线程
                sd.start();
                //判断启动后线程的isAlive()值，输出true
                System.out.println(sd.isAlive());
            }
            //当线程处于新建、死亡两种状态时，isAlive()方法返回false
            //当i > 20时，该线程肯定已经启动过了，若sd.isAlive()为假时
            //那么就是死亡状态了
            if(i > 20 && !sd.isAlive()){
                //试图再次启动该线程
                sd.start();
            }
        }
    }
}

　　　　不要对处于死亡状态的线程调用start()方法，程序只能对新建状态的线程调用start()方法，对新建线程调用两次start()方法也是错误的。

控制线程：

　　join线程：

　　　　Thread提供了让一个线程等待另一个线程完成的方法——join()方法。

　　　　当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join线程执行完为止。

　　　　join()方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有小问题得到处理后，再调用主线程进一步操作：

public class JoinThread extends Thread{
    //提供一个有参数的构造器，用于设置该线程的名字
    public JoinThread(String name){
        super(name);
    }
    //重写run()方法，定义线程执行体
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println(getName() + " " + i);
        }
    }
    
    public static void main(String[] args) throws Exception{
        //启动子线程
        new JoinThread("新线程").start();
        for(int i = 0; i < 100; i++){
            
            if(i == 20){
                JoinThread jt = new JoinThread("被Join的线程");
                jt.start();
                //main线程调用了jt线程的join()方法，main线程必须等jt执行结束才会向下执行
                jt.join();
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

　　　　当主线程的循环变量i等于20时，启动了名为“被Join的线程”的线程，该线程不会和main线程并发执行，main必须等该线程执行结束后才可以向下执行。

后台线程：

　　在后台运行，它的任务是为其他的线程提供服务，这种线程被称为“后台线程”（Daemon Thread），JVM的垃圾回收线程就是典型的后台线程。

　　后台线程有个特征：若所有的前台线程都死亡，后台线程会自动死亡。

　　调用Thread对象的setDaemon(true)方法可将指定线程设置成后台线程。

public class DaemonThread extends Thread{
    //定义后台线程的线程执行体与普通线程没有任何区别
    public void run(){
        for(int i = 0; i < 1000; i++){
            System.out.println(getName() + " " + i);
        }
    }
    
    public static void main(String[] args){
        DaemonThread t = new DaemonThread();
        //将此线程设置成后台线程
        t.setDaemon(true);
        //启动后台线程
        t.start();
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        //------程序执行到此处，前台线程（main线程）结束------
        //后台线程也应该随之结束
    }
}

　　　　从程序中可以看出主线程默认是前台线程，前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。

　　　　setDaemon(true)必须在start()方法之前调用。

线程睡眠：

　　让当前正在执行的线程暂停一段时间，并进入阻塞状态，可通过调用Thread类的静态sleep()方法来实现。

import java.util.Date;

public class SleepTest{
    public static void main(String[] args) throws Exception{
        for(int i = 0; i < 10; i++){
            System.out.println("当前时间：" + new Date());
            //调用sleep()方法让当前线程暂停1s
            Thread.sleep(1000);
        }
    }
}

　　　　让线程睡眠1s。

线程让步：

　　yield()方法是一个和sleep()方法有点相似的方法，yield()也是Thread类提供的一个静态方法。可以让当前正在执行的线程暂停，但不会阻塞该线程，只是将该线程转入就绪状态

　　实际上，当某个线程调用了yield()方法暂停之后，只有优先级和当前线程相同，或优先级比当前线程更高的处于就绪状态的线程才会获得执行的机会。

public class YieldTest extends Thread{
    public YieldTest(String name){
        super(name);
    }
    //定义run()方法作为线程执行体
    public void run(){
        for(int i = 0; i < 50; i++){
            System.out.println(getName() + " " + i);
            //当i等于20时，使用yield()方法让当前进程让步
            if(i == 20){
                Thread.yield();
            }
        }
    }
    
    public static void main(String[] args){
        //启动两个并发线程
        YieldTest yt1 = new YieldTest("高级");
        //将yt1线程设置成最高优先级
        yt1.setPriority(Thread.MAX_PRIORITY);
        yt1.start();
        YieldTest yt2 = new YieldTest("低级");
        //将yt2线程设置成最低级优先级
        yt2.setPriority(Thread.MIN_PRIORITY);
        yt2.start();
    }
}

　　　　由于电脑是多CPU，所以yield()方法不明显。

改变线程的优先级：

　　setPriority()方法用来改变线程的优先级：

public class PriorityTest extends Thread{
    //定义一个有参数的构造器，用于创建线程时指定name
    public PriorityTest(String name){
        super(name);
    }
    public void run(){
        for(int i = 0; i < 50; i++){
            System.out.println(getName() + "，其优先级是：" + getPriority() + "，循环变量的值为：" + i);
        }
    }
    
    public static void main(String[] args){
        //改变主线程的优先级
        Thread.currentThread().setPriority(6);
        for(int i = 0; i < 30; i++){
            if(i == 10){
                PriorityTest low = new PriorityTest("低级");
                low.start();
                System.out.println("创建之初的优先级：" + low.getPriority());
                //设置该线程为最低优先级
                low.setPriority(Thread.MIN_PRIORITY);
            }
            if(i == 20){
                PriorityTest high = new PriorityTest("高级");
                high.start();
                System.out.println("创建之初的优先级：" + high.getPriority());
                //设置该线程为最高优先级
                high.setPriority(Thread.MAX_PRIORITY);
            }
        }
    }
}

　　　　改变了主线程的优先级为6，所以主线程所创建的子线程的优先级默认都是6。

线程同步：

　　线程安全问题：

　　有一个经典的问题——银行取钱问题：

　　　　1.用户输入账号、密码，系统判断用户的账号、密码是否匹配。

　　　　2.用户输入取款金额

　　　　3.系统判断账户余额是否大于取款金额

　　　　4.若余额大于取款金额，则取款成功；小于取款金额，则取款失败

public class Account
{
    // 封装账户编号、账户余额的两个成员变量
    private String accountNo;
    private double balance;
    public Account(){}
    // 构造器
    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }
    // 此处省略了accountNo和balance的setter和getter方法

    // accountNo的setter和getter方法
    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
        return this.accountNo;
    }

    // balance的setter和getter方法
    public void setBalance(double balance)
    {
        this.balance = balance;
    }
    public double getBalance()
    {
        return this.balance;
    }

    // 下面两个方法根据accountNo来重写hashCode()和equals()方法
    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 class DrawThread extends Thread
{
    // 模拟用户账户
    private Account account;
    // 当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name , Account account
        , double drawAmount)
    {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }
    // 当多条线程修改同一个共享数据时，将涉及数据安全问题。
    public void run()
    {
        // 账户余额大于取钱数目
        if (account.getBalance() >= drawAmount)
        {
            // 吐出钞票
            System.out.println(getName()
                + "取钱成功！吐出钞票:" + drawAmount);
            
            try
            {
                Thread.sleep(1);
            }
            catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
            
            // 修改余额
            account.setBalance(account.getBalance() - drawAmount);
            System.out.println("	余额为: " + account.getBalance());
        }
        else
        {
            System.out.println(getName() + "取钱失败！余额不足！");
        }
    }
}

public class DrawTest
{
    public static void main(String[] args)
    {
        // 创建一个账户
        Account acct = new Account("1234567" , 1000);
        // 模拟两个线程对同一个账户取钱
        new DrawThread("甲" , acct , 800).start();
        new DrawThread("乙" , acct , 800).start();
    }
}

　　上面结果都是错误的，所以这就是线程的安全问题。

同步代码块：

　　上面代码出错的主要原因是在执行run()方法的时候同一个线程没有一次执行完毕，导致余额总是大于800。

　　为了解决上面出现的问题，Java的多线程支持引入同步监视器，使用同步件事器的通用方法就是同步代码块。格式如下：

　　　　synchronized(obj){

　　　　　　...

　　　　　　//此处的代码就是同步代码块

　　　　}

　　上面格式中synchronized括号中的obj就是同步监视器，含义是：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。

　　任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。

　　同步监视器的目的：阻止两个线程对同一个共享资源进行并发访问，因此通常推荐使用可能被并发访问的共享资源充当同步监视器，对于上面的取钱模拟程序，应考虑账户作为

　　　同步监视器：

public class DrawThread extends Thread
{
    // 模拟用户账户
    private Account account;
    // 当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name , Account account
        , double drawAmount)
    {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }
    // 当多条线程修改同一个共享数据时，将涉及数据安全问题。
    public void run()
    {
        // 使用account作为同步监视器，任何线程进入下面同步代码块之前，
        // 必须先获得对account账户的锁定——其他线程无法获得锁，也就无法修改它
        // 这种做法符合：“加锁 → 修改 → 释放锁”的逻辑
        synchronized (account)
        {
            // 账户余额大于取钱数目
            if (account.getBalance() >= drawAmount)
            {
                // 吐出钞票
                System.out.println(getName()
                    + "取钱成功！吐出钞票:" + drawAmount);
                try
                {
                    Thread.sleep(1);
                }
                catch (InterruptedException ex)
                {
                    ex.printStackTrace();
                }
                // 修改余额
                account.setBalance(account.getBalance() - drawAmount);
                System.out.println("	余额为: " + account.getBalance());
            }
            else
            {
                System.out.println(getName() + "取钱失败！余额不足！");
            }
        }
        // 同步代码块结束，该线程释放同步锁
    }
}

　　　　上面程序使用synchronized将run()方法体修改成同步代码块，该同步代码块的同步监视器是account对象。

同步方法：

　　就是使用synchronized关键字修饰某个方法。对于synchronized修饰的实例方法（非static方法）而言，无需显式指定同步监视器，同步方法的同步监视器是this，也就是调用该

　　　方法的对象。

public class Account
{
    // 封装账户编号、账户余额两个成员变量
    private String accountNo;
    private double balance;
    public Account(){}
    // 构造器
    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    // accountNo的setter和getter方法
    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
        return this.accountNo;
    }
    // 因此账户余额不允许随便修改，所以只为balance提供getter方法，
    public double getBalance()
    {
        return this.balance;
    }

    // 提供一个线程安全draw()方法来完成取钱操作
    public synchronized void draw(double drawAmount)
    {
        // 账户余额大于取钱数目
        if (balance >= drawAmount)
        {
            // 吐出钞票
            System.out.println(Thread.currentThread().getName()
                + "取钱成功！吐出钞票:" + drawAmount);
            try
            {
                Thread.sleep(1);
            }
            catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
            // 修改余额
            balance -= drawAmount;
            System.out.println("	余额为: " + balance);
        }
        else
        {
            System.out.println(Thread.currentThread().getName()
                + "取钱失败！余额不足！");
        }
    }

    // 下面两个方法根据accountNo来重写hashCode()和equals()方法
    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 class DrawThread extends Thread
{
    // 模拟用户账户
    private Account account;
    // 当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name , Account account
        , double drawAmount)
    {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }
    // 当多条线程修改同一个共享数据时，将涉及数据安全问题。
    public void run()
    {
        // 直接调用account对象的draw方法来执行取钱
        // 同步方法的同步监视器是this，this代表调用draw()方法的对象。
        // 也就是说：线程进入draw()方法之前，必须先对account对象的加锁。
        account.draw(drawAmount);
    }
}

public class DrawTest
{
    public static void main(String[] args)
    {
        // 创建一个账户
        Account acct = new Account("1234567" , 1000);
        // 模拟两个线程对同一个账户取钱
        new DrawThread("甲" , acct , 800).start();
        new DrawThread("乙" , acct , 800).start();
    }
}

同步锁：

　　java5提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。

import java.util.concurrent.locks.*;

public class Account
{
    // 定义锁对象
    private final ReentrantLock lock = new ReentrantLock();
    // 封装账户编号、账户余额的两个成员变量
    private String accountNo;
    private double balance;
    public Account(){}
    // 构造器
    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    // accountNo的setter和getter方法
    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
        return this.accountNo;
    }
    // 因此账户余额不允许随便修改，所以只为balance提供getter方法，
    public double getBalance()
    {
        return this.balance;
    }

    // 提供一个线程安全draw()方法来完成取钱操作
    public void draw(double drawAmount)
    {
        // 加锁
        lock.lock();
        try
        {
            // 账户余额大于取钱数目
            if (balance >= drawAmount)
            {
                // 吐出钞票
                System.out.println(Thread.currentThread().getName()
                    + "取钱成功！吐出钞票:" + drawAmount);
                try
                {
                    Thread.sleep(1);
                }
                catch (InterruptedException ex)
                {
                    ex.printStackTrace();
                }
                // 修改余额
                balance -= drawAmount;
                System.out.println("	余额为: " + balance);
            }
            else
            {
                System.out.println(Thread.currentThread().getName()
                    + "取钱失败！余额不足！");
            }
        }
        finally
        {
            // 修改完成，释放锁
            lock.unlock();
        }
    }

    // 下面两个方法根据accountNo来重写hashCode()和equals()方法
    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;
    }
}

　　在Account类中定义ReentrantLock对象，在draw()方法中上锁，执行draw()方法后释放锁。

死锁：

　　死锁的情况很容易发生，如在系统中出现多个同步监听器：

class A
{
    public synchronized void foo( B b )
    {
        System.out.println("当前线程名: " + Thread.currentThread().getName()
            + " 进入了A实例的foo()方法" );     // ①
        try
        {
            Thread.sleep(200);
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
        System.out.println("当前线程名: " + Thread.currentThread().getName()
            + " 企图调用B实例的last()方法");    // ③
        b.last();
    }
    public synchronized void last()
    {
        System.out.println("进入了A类的last()方法内部");
    }
}
class B
{
    public synchronized void bar( A a )
    {
        System.out.println("当前线程名: " + Thread.currentThread().getName()
            + " 进入了B实例的bar()方法" );   // ②
        try
        {
            Thread.sleep(200);
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
        System.out.println("当前线程名: " + Thread.currentThread().getName()
            + " 企图调用A实例的last()方法");  // ④
        a.last();
    }
    public synchronized void last()
    {
        System.out.println("进入了B类的last()方法内部");
    }
}
public class DeadLock implements Runnable
{
    A a = new A();
    B b = new B();
    public void init()
    {
        Thread.currentThread().setName("主线程");
        // 调用a对象的foo方法
        a.foo(b);
        System.out.println("进入了主线程之后");
    }
    public void run()
    {
        Thread.currentThread().setName("副线程");
        // 调用b对象的bar方法
        b.bar(a);
        System.out.println("进入了副线程之后");
    }
    public static void main(String[] args)
    {
        DeadLock dl = new DeadLock();
        // 以dl为target启动新线程
        new Thread(dl).start();
        // 调用init()方法
        dl.init();
    }
}

线程通信：

public class Account
{
    // 封装账户编号、账户余额的两个成员变量
    private String accountNo;
    private double balance;
    // 标识账户中是否已有存款的旗标
    private boolean flag = false;

    public Account(){}
    // 构造器
    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    // accountNo的setter和getter方法
    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
        return this.accountNo;
    }
    // 因此账户余额不允许随便修改，所以只为balance提供getter方法，
    public double getBalance()
    {
        return this.balance;
    }

    public synchronized void draw(double drawAmount)
    {
        try
        {
            // 如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
            if (!flag)
            {
                wait();
            }
            else
            {
                // 执行取钱
                System.out.println(Thread.currentThread().getName()
                    + " 取钱:" +  drawAmount);
                balance -= drawAmount;
                System.out.println("账户余额为：" + balance);
                // 将标识账户是否已有存款的旗标设为false。
                flag = false;
                // 唤醒其他线程
                notifyAll();
            }
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
    }
    public synchronized void deposit(double depositAmount)
    {
        try
        {
            // 如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
            if (flag)             //①
            {
                wait();
            }
            else
            {
                // 执行存款
                System.out.println(Thread.currentThread().getName()
                    + " 存款:" +  depositAmount);
                balance += depositAmount;
                System.out.println("账户余额为：" + balance);
                // 将表示账户是否已有存款的旗标设为true
                flag = true;
                // 唤醒其他线程
                notifyAll();
            }
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
    }

    // 下面两个方法根据accountNo来重写hashCode()和equals()方法
    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 class DrawThread extends Thread
{
    // 模拟用户账户
    private Account account;
    // 当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name , Account account
        , double drawAmount)
    {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }
    // 重复100次执行取钱操作
    public void run()
    {
        for (int i = 0 ; i < 100 ; i++ )
        {
            account.draw(drawAmount);
        }
    }
}

public class DepositThread extends Thread
{
    // 模拟用户账户
    private Account account;
    // 当前取钱线程所希望存款的钱数
    private double depositAmount;
    public DepositThread(String name , Account account
        , double depositAmount)
    {
        super(name);
        this.account = account;
        this.depositAmount = depositAmount;
    }
    // 重复100次执行存款操作
    public void run()
    {
        for (int i = 0 ; i < 100 ; i++ )
        {
            account.deposit(depositAmount);
        }
    }
}

public class DrawTest
{
    public static void main(String[] args)
    {
        // 创建一个账户
        Account acct = new Account("1234567" , 0);
        new DrawThread("取钱者" , acct , 800).start();
        new DepositThread("存款者甲" , acct , 800).start();
        new DepositThread("存款者乙" , acct , 800).start();
        new DepositThread("存款者丙" , acct , 800).start();
    }
}

　　　　上面程序代表存款者和取款者，存款者将钱存入账户唤醒取款者，取款者从账户取出钱后唤醒所有线程。取款者是随机的。程序使用synchronized方法，flag标志位，wait()

　　　　　方法、notify()方法、notifyAll()方法进行同步操作。

使用Condition控制线程通信：　　

　　Condition和Lock对象协作，实现上面程序的功能。这时候Lock替代了同步方法或同步代码块，Condition替代了同步监视器的功能。

　　Condition实例被绑定在一个Lock对象上。要获得特定Lock实例的Condition实例，调用Lock对象的newCondition()方法即可。

修改上面程序的Account代码：

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class Account
{
    // 显式定义Lock对象
    private final Lock lock = new ReentrantLock();
    // 获得指定Lock对象对应的Condition
    private final Condition cond  = lock.newCondition();
    // 封装账户编号、账户余额的两个成员变量
    private String accountNo;
    private double balance;
    // 标识账户中是否已有存款的旗标
    private boolean flag = false;

    public Account(){}
    // 构造器
    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    // accountNo的setter和getter方法
    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
        return this.accountNo;
    }
    // 因此账户余额不允许随便修改，所以只为balance提供getter方法，
    public double getBalance()
    {
        return this.balance;
    }

    public void draw(double drawAmount)
    {
        // 加锁
        lock.lock();
        try
        {
            // 如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
            if (!flag)
            {
                cond.await();
            }
            else
            {
                // 执行取钱
                System.out.println(Thread.currentThread().getName()
                    + " 取钱:" +  drawAmount);
                balance -= drawAmount;
                System.out.println("账户余额为：" + balance);
                // 将标识账户是否已有存款的旗标设为false。
                flag = false;
                // 唤醒其他线程
                cond.signalAll();
            }
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
        // 使用finally块来释放锁
        finally
        {
            lock.unlock();
        }
    }
    public void deposit(double depositAmount)
    {
        lock.lock();
        try
        {
            // 如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
            if (flag)             // ①
            {
                cond.await();
            }
            else
            {
                // 执行存款
                System.out.println(Thread.currentThread().getName()
                    + " 存款:" +  depositAmount);
                balance += depositAmount;
                System.out.println("账户余额为：" + balance);
                // 将表示账户是否已有存款的旗标设为true
                flag = true;
                // 唤醒其他线程
                cond.signalAll();
            }
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
        // 使用finally块来释放锁
        finally
        {
            lock.unlock();
        }
    }

    // 下面两个方法根据accountNo来重写hashCode()和equals()方法
    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;
    }
}

　　　　程序通过上锁和Condition控制实现存款和取款

使用阻塞队列（BlockingQueue）控制线程通信：

　　BlockingQueue是Queue的子接口，是线程同步的工具。BlockingQueue具有一个特征：当生产者线程试图向BlockingQueue中放入元素时，若该队列已满，则该线程被阻塞；

　　　当消费者线程试图从BlockingQueue中取出元素时，若该队列已空，则该线程被阻塞。

import java.util.concurrent.*;

class Producer extends Thread
{
    private BlockingQueue<String> bq;
    public Producer(BlockingQueue<String> bq)
    {
        this.bq = bq;
    }
    public void run()
    {
        String[] strArr = new String[]
        {
            "Java",
            "Struts",
            "Spring"
        };
        for (int i = 0 ; i < 99 ; i++ )
        {
            System.out.println(getName() + "生产者准备生产集合元素！");
            try
            {
                Thread.sleep(200);
                // 尝试放入元素，如果队列已满，线程被阻塞
                bq.put(strArr[i % 3]);
            }
            catch (Exception ex){ex.printStackTrace();}
            System.out.println(getName() + "生产完成：" + bq);
        }
    }
}
class Consumer extends Thread
{
    private BlockingQueue<String> bq;
    public Consumer(BlockingQueue<String> bq)
    {
        this.bq = bq;
    }
    public void run()
    {
        while(true)
        {
            System.out.println(getName() + "消费者准备消费集合元素！");
            try
            {
                Thread.sleep(200);
                // 尝试取出元素，如果队列已空，线程被阻塞
                bq.take();
            }
            catch (Exception ex){ex.printStackTrace();}
            System.out.println(getName() + "消费完成：" + bq);
        }
    }
}
public class BlockingQueueTest2
{
    public static void main(String[] args)
    {
        // 创建一个容量为1的BlockingQueue
        BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
        // 启动3条生产者线程
        new Producer(bq).start();
        new Producer(bq).start();
        new Producer(bq).start();
        // 启动一条消费者线程
        new Consumer(bq).start();
    }
}

线程组和未处理的异常：

　　Java使用ThreadGroup来表示线程组，可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。

class MyThread extends Thread
{
    // 提供指定线程名的构造器
    public MyThread(String name)
    {
        super(name);
    }
    // 提供指定线程名、线程组的构造器
    public MyThread(ThreadGroup group , String name)
    {
        super(group, name);
    }
    public void run()
    {
        for (int i = 0; i < 20 ; i++ )
        {
            System.out.println(getName() + " 线程的i变量" + i);
        }
    }
}
public class ThreadGroupTest
{
    public static void main(String[] args)
    {
        // 获取主线程所在的线程组，这是所有线程默认的线程组
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();
        System.out.println("主线程组的名字："
            + mainGroup.getName());
        System.out.println("主线程组是否是后台线程组："
            + mainGroup.isDaemon());
        new MyThread("主线程组的线程").start();
        ThreadGroup tg = new ThreadGroup("新线程组");
        tg.setDaemon(true);
        System.out.println("tg线程组是否是后台线程组："
            + tg.isDaemon());
        MyThread tt = new MyThread(tg , "tg组的线程甲");
        tt.start();
        new MyThread(tg , "tg组的线程乙").start();
    }
}

// 定义自己的异常处理器
class MyExHandler implements Thread.UncaughtExceptionHandler
{
    // 实现uncaughtException方法，该方法将处理线程的未处理异常
    public void uncaughtException(Thread t, Throwable e)
    {
        System.out.println(t + " 线程出现了异常：" + e);
    }
}
public class ExHandler
{
    public static void main(String[] args)
    {
        // 设置主线程的异常处理器
        Thread.currentThread().setUncaughtExceptionHandler
            (new MyExHandler());
        int a = 5 / 0;     // ①
        System.out.println("程序正常结束！");
    }
}