Java笔记(二十)……线程间通信

概述

当需要多线程配合完成一项任务时，往往需要用到线程间通信，以确保任务的稳步快速运行

相关语句

wait()：挂起线程，释放锁，相当于自动放弃了执行权限

notify()：唤醒wait等待队列里的第一个线程

notifyAll()：唤醒所有等待队列中的线程

他们都使用在同步中，因为要对持有监视器(锁)的线程操作，所以要使用在同步中，因为只有同步才具有锁

相关问题

为什么这些操作线程的方法要定义在Object类中

因为这些方法是依赖于锁进行的，而锁又是任意对象，所以这些方法必须定义在Object中，才可以被任意对象的锁调用

为什么使用notifyAll而不是notify

因为notify唤醒的只是等待队列里的第一个线程，该线程不确定，有可能是对方线程，也有可能是本方线程，所以要使用notifyAll来唤醒所有线程，并配合while循环判断标记才能保证运行的正常

实例代码

//定义一把枪
class Gun
{
    int bullet;
    boolean isEmpty;

    Gun()
    {
        bullet = 0;
        isEmpty = true;
    }

    //上子弹
    synchronized void putBullet()
    {
        //之所以用while，是因为notifyAll会唤醒所有线程
        //若唤醒了本方线程，则需要再判断一次条件，确保本方线程不会冲突
        while(isEmpty != true)
        {
            try
            {
                wait();
            }
            catch (Exception e)
            {
            }
        }

        bullet+=7;
        System.out.println("Put bullet : "+ bullet);
        isEmpty = false;
        //上满子弹后，唤醒shot线程发射子弹
        notifyAll();
    }

    //射出子弹
    synchronized void shotBullet()
    {
        while(isEmpty != false)
        {
            try
            {
                wait();
            }
            catch (Exception e)
            {
            }
        }
        System.out.println("Shot bullet : "+bullet--);

        if(bullet == 0)
        {
            isEmpty = true;
            //子弹打光之后，唤醒put线程继续上子弹
            notifyAll();
        }

    }
}
class PutBullet implements Runnable
{
    private Gun g;
    PutBullet(Gun g)
    {
        this.g = g;
    }
    public void run()
    {
        while(true)
        {
            g.putBullet();
        }
    }
}

class ShotBullet implements Runnable
{
    private Gun g;
    ShotBullet(Gun g)
    {
        this.g = g;
    }
    public void run()
    {
        while(true)
        {
            g.shotBullet();
        }
    }
}

class MutiThreadDemo
{
    public static void main(String[] args)
    {
        Gun g = new Gun();
        new Thread(new PutBullet(g)).start();
        new Thread(new ShotBullet(g)).start();
        new Thread(new PutBullet(g)).start();
        new Thread(new ShotBullet(g)).start();
    }
}

JDK1.5之后的升级

JDK1.5中提供了多线程的升级解决方案

将同步synchronized替换成Lock操作

将Object中的wait，notify，notifyAll替换成condition对象，该对象可以对Lock锁进行获取

lock_condition机制可以实现只唤醒对方线程，条理更清晰，所以也省去了循环判断标记的动作

代码如下：

import java.util.concurrent.locks.*;

//定义一把枪
class Gun
{
    private int bullet;
    private boolean isEmpty;

    private Lock lock = new ReentrantLock();

    private Condition condition_put = lock.newCondition();
    private Condition condition_shot = lock.newCondition();

    Gun()
    {
        bullet = 0;
        isEmpty = true;
    }

    //上子弹
    void putBullet()
    {
        lock.lock();
        try
        {
            //之所以用while，是因为notifyAll会唤醒所有线程
            //若唤醒了本方线程，则需要再判断一次条件，确保本方线程不会冲突
            if(!isEmpty)
                condition_put.await();

            bullet+=7;
            System.out.println("Put bullet : "+ bullet);
            isEmpty = false;
            //上满子弹后，唤醒shot线程发射子弹
            condition_shot.signal();
        }
        catch (InterruptedException e)
        {
        }
        finally
        {
            //释放锁的动作一定完成
            lock.unlock();
        }

    }

    //射出子弹
    void shotBullet()
    {
        lock.lock();
        try
        {
            if(isEmpty)
                condition_shot.await();
            System.out.println("Shot bullet : "+bullet--);

            if(bullet == 0)
            {
                isEmpty = true;
                //子弹打光之后，唤醒put线程继续上子弹
                condition_put.signal();
            }
        }
        catch (InterruptedException e)
        {
        }
        finally
        {
            lock.unlock();
        }

    }
}
class PutBullet implements Runnable
{
    private Gun g;
    PutBullet(Gun g)
    {
        this.g = g;
    }
    public void run()
    {
        while(true)
        {
            g.putBullet();
        }
    }
}

class ShotBullet implements Runnable
{
    private Gun g;
    ShotBullet(Gun g)
    {
        this.g = g;
    }
    public void run()
    {
        while(true)
        {
            g.shotBullet();
        }
    }
}

class MutiThreadDemo2
{
    public static void main(String[] args)
    {
        Gun g = new Gun();
        new Thread(new PutBullet(g)).start();
        new Thread(new ShotBullet(g)).start();
        new Thread(new PutBullet(g)).start();
        new Thread(new ShotBullet(g)).start();
    }
}

停止线程

如何停止线程

只有一种，run方法结束

开启的多线程通常都是循环结构，可以通过修改循环条件来结束run方法

但是当线程挂起时，有时会执行不到循环条件，一直挂起，这样就不会结束，这时需要对冻结状态的线程进行清除

Thread类为我们提供了一种方法，即interrupt()方法，用于解除挂起状态，恢复到运行状态，所以我们既可以改变循环条件，也可以通过处理InterruptedException异常来结束循环，代码如下：

import java.util.concurrent.locks.*;

//定义一把枪
class Gun
{
    private int bullet;
    private boolean isEmpty;

    private Lock lock = new ReentrantLock();

    private Condition condition_put = lock.newCondition();
    private Condition condition_shot = lock.newCondition();

    Gun()
    {
        bullet = 0;
        isEmpty = true;
    }

    //上子弹
    void putBullet() throws InterruptedException
    {
        lock.lock();
        try
        {
            //之所以用while，是因为notifyAll会唤醒所有线程
            //若唤醒了本方线程，则需要再判断一次条件，确保本方线程不会冲突
            if(!isEmpty)
                condition_put.await();

            bullet+=7;
            System.out.println("Put bullet : "+ bullet);
            isEmpty = false;
            //上满子弹后，唤醒shot线程发射子弹
            condition_shot.signal();
        }
        finally
        {
            //释放锁的动作一定完成
            lock.unlock();
        }

    }

    //射出子弹
    void shotBullet() throws InterruptedException
    {
        lock.lock();
        try
        {
            if(isEmpty)
                condition_shot.await();
            System.out.println("Shot bullet : "+bullet--);

            if(bullet == 0)
            {
                isEmpty = true;
                //子弹打光之后，唤醒put线程继续上子弹
                condition_put.signal();
            }
        }
        finally
        {
            lock.unlock();
        }

    }
}
class PutBullet implements Runnable
{
    private Gun g;
    PutBullet(Gun g)
    {
        this.g = g;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                g.putBullet();
            }
            catch (InterruptedException e)
            {
                break;
            }

        }
    }
}

class ShotBullet implements Runnable
{
    private Gun g;
    ShotBullet(Gun g)
    {
        this.g = g;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                g.shotBullet();
            }
            //对异常进行处理，以退出循环
            catch (InterruptedException e)
            {
                break;
            }
        }
    }
}

class MutiThreadDemo2
{
    public static void main(String[] args)
    {
        Gun g = new Gun();
        Thread t1 = new Thread(new PutBullet(g));
        Thread t2 = new Thread(new ShotBullet(g));
        Thread t3 = new Thread(new PutBullet(g));
        Thread t4 = new Thread(new ShotBullet(g));

        t1.start();
        t2.start();
        t3.start();
        t4.start();

        try
        {
            Thread.sleep(5000);
        }
        catch (Exception e)
        {
        }

        t1.interrupt();
        t2.interrupt();
        t3.interrupt();
        t4.interrupt();
    }
}

线程类的其他方法

setPriority(int num)

设置线程运行的优先级，效果不绝对，只是个概率问题

setDaemon(boolean b)

守护线程，也叫后台线程，意味着当前台线程结束时，后台线程无论是否挂起，都会退出线程

join()

当A线程执行到B的join方法时，会等待Join方法结束，再继续执行，join方法一般用来临时加入线程操作

toString()

自定义线程名称