线程同步、死锁和通信——Java多线程（二）

一、多线程同步

上一篇随笔中，我曾遇到对多线程程序的多次运行结果不一致的情况，这主要是因为没有对这些线程在访问临界资源做必要的控制，而接下来就用线程的同步来解决这个问题。

1.同步代码块

class RunnableDemo implements Runnable 
{
    private int tickets=5;
    public void run()
    {
        while(true)
        {
            synchronized(this)//同步代码块语法定义如下
            {
                if(tickets<=0) break;
                try{
                    Thread.sleep(100);
                }
                catch(Exception e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"出售票："+tickets);
                tickets -= 1;
            }
        }
    }
}

public class ThreadTest
{
    public static void main(String[] args)
    {
        RunnableDemo r = new RunnableDemo();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
}

在同一时刻只能由一个线程进入同步代码块内运行，只有当该线程离开同步代码块后，其他线程才能进入同步代码块内运行。

2.同步方法

即：把上述例子中同步代码块的内容，专门封装在一个方法里，通过在run()方法中调用创建的方法实现相应的功能。

class RunnableDemo implements Runnable 
{
    private int tickets=5;
    public void run()
    {
        while(tickets>0)
        {
            sale();
        }
    }
    public synchronized void sale()//同步方法
    {
        if(tickets>0){
        try{
            Thread.sleep(100);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"出售票："+tickets);
        tickets -= 1;
        }
    }
}

public class ThreadTest
{
    public static void main(String[] args)
    {
        RunnableDemo r = new RunnableDemo();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
}

 二、死锁

如果有一组进程（或线程），线程1 已经占据资源R1，并持有资源R1上的锁，而且正在等待资源R2开锁；线程2已经占据资源R2，并拥有资源R2上的锁，却正在等待R1开锁。那么这两个线程都不释放自己占据的资源，同时申请不到对方资源上的锁，它们只能永远等待下去。这种现象就叫做死锁。

预防死锁的一种方法：利用有序资源分配策略——要求线程申请资源必须按照以编号上升的次序依次申请。

三、线程间通信

同属于一个进程的多个线程，是共享地址空间的，它们可以相互通信，共同协作来完成指定任务。

Java是通过Object类的wait()、notify()、notifyAll()这几个方法来实现线程间的通信。

wait():线程进入睡眠状态，直到其他线程进入并调用notify()或notifyAll()为止。

notify():唤醒在该同步代码块中第1个调用wait()的线程。

notifyAll():唤醒在该同步代码块中所有调用wait()的线程，高优先级最先被唤醒。

class Producer implements Runnable
{
    Person q = null;
    public Producer(Person q)
    {
        this.q=q;
    }
    @Override
    public void run()
    {
        for(int i=0;i<10;i++)
        {
            if(i%2==0)
            {
                q.set("张三","男");
            }
            else{
                q.set("李四","女");
            }
        }
    }
}
class Consumer implements Runnable
{
    Person q = null;
    public Consumer(Person q)
    {
        this.q=q;
    }
    @Override
    public void run() 
    {
        for(int i=0;i<10;++i)
        {
            q.get();
        }
    }
}
class Person
{
    private String name = "李四";
    private String sex = "女";
    private boolean bFull = false;//当Consumer线程取走数据后，false
    public synchronized void set(String name,String sex)
    {
        if(bFull)
        {
            try
            {
                wait();//后来的线程要等待
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        this.name = name;
        this.sex = sex;
        bFull = true;//当Producer线程放入数据后，true
        notify();//唤醒最先到达的线程
    }
    public synchronized void get()
    {
        if(!bFull)
        {
            try{
                wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println(name+"——>"+sex);
        bFull = false;
        notify();
    }
}
public class ThreadCommunation
{
    public static void main(String[] args)
    {
        Person q = new Person();
        new Thread(new Producer(q)).start();
        new Thread(new Consumer(q)).start();
    }
}

***注意：wait()、notify()、notifyAll()这三个方法必须在synchronized方法中调用，该线程必须得到该对象的所有权。

四、线程的生命周期

控制线程生命周期的方法：suspend()、resume()、stop()方法，但是这三个方法都不推荐使用。

若想控制线程的生命周期，推荐使用在run()方法中添加循环条件的方法来实现对线程生命周期的控制。