Java：多线程<三>死锁、线程间通讯

死锁：

同步嵌套同步，而且使用的锁不是同一把锁时就可能出现死锁

class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag = flag;
    }

    public void run()
    {
        if(flag)
        {
            while(true)
            {
                synchronized(MyLock.locka)
                {
                    System.out.println(Thread.currentThread().getName()+"...if locka ");
                    synchronized(MyLock.lockb)
                    {
                        System.out.println(Thread.currentThread().getName()+"..if lockb");                    
                    }
                }
            }
        }
        else
        {
            while(true)
            {
                synchronized(MyLock.lockb)
                {
                    System.out.println(Thread.currentThread().getName()+"..else lockb");
                    synchronized(MyLock.locka)
                    {
                        System.out.println(Thread.currentThread().getName()+".....else locka");
                    }
                }
            }
        }
    }
}


class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object();
}

class  DeadLockTest
{
    public static void main(String[] args) 
    {
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}

线程间通讯：

其实就是多线程操作同一个资源，但是操作的动作不同。

例，用多线程操作生成一个人名+性别（男的用英文表示，女的用中文表示），然后打印。

class Res
{
    String name;
    String sex;
}

class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)
            {
                if (x==0)
                {
                    r.name = "Mike";
                    r.sex="man";
                }
                else
                {
                    r.name = "丽丽";
                    r.sex="女";
                }
            }
            x = (x+1)%2;
        }
    }
}

class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            synchronized(r)
            {
                System.out.println(r.name + "..." +r.sex);
            }            
        }
    }
}

class  ThreadCommunication
{
    public static void main(String[] args) 
    {
        Res r = new Res();
        Input in = new Input(r);
        Output out = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();
    }
}

注意：1，操作的共同资源必须上锁；2，使用的锁在内存中一定要保证是唯一的；

在上个例子中，并不是按照我们期待的那样，生成一个对象然后打印该对象，即输入一个就输出一个，这就需要用到等待-唤醒机制。

等待-唤醒：

wait:

notify:

notifyall:

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

为什么这些操作线程的方法，要定义在Object类中呢？以为你这些方法在操作同步中线程时，都必须要表示它们所操作线程持有的锁。只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。也就是说等待和唤醒必须是同一个锁。而锁可以是任意对象，所以被任意对象调用的方法定义在Object中。

class Res
{
    String name;
    String sex;
    Boolean flag=false;
}

class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)
            {
                if(r.flag)
                {
                    try
                    {
                        r.wait();//如果flag=ture,说明资源中已经有了生产的对象，那么不再生产了，生产线程就wait
                    }
                    catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                }
                if (x==0)
                {
                    r.name = "Mike";
                    r.sex="man";                
                }
                else
                {
                    r.name = "丽丽";
                    r.sex="女";
                }
                r.flag = true;//改变flag标记
                r.notify();//唤醒线程池中的第一个等待线程，只在本程序中就是out
            }
            x = (x+1)%2;
            
        }
    }
}

class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {            
            synchronized(r)
            {    
                if(!r.flag)
                {
                    try
                    {
                        r.wait();//如果资源中没有生产对象，那么就没有可以打印的对象，这是输出就wait
                    }
                    catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                }
                    
                System.out.println(r.name + "..." +r.sex);
                r.flag = false;//改变标记
                r.notify();//唤醒线程池中的第一个等待线程，本程序中即in
            }            
        }
    }
}

class  ThreadCommunication
{
    public static void main(String[] args) 
    {
        Res r = new Res();
        Input in = new Input(r);
        Output out = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();
    }
}

优化代码

class Res
{
    private String name;
    private String sex;
    private Boolean flag=false;

    public synchronized void set(String name,String sex)
    {
        if (flag)
        {
            try
            {
                this.wait();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            this.name = name;
            this.sex = sex;
            flag = ture;
            this.notify();
        }
        
    }
    public synchronized void out()
    {
        if (!flag)
        {
            try
            {
                this.wait();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            System.out.println(name + "..." + sex);
            flag = false;
            this.notify();
        }        
    }
}

class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)
            {
                if (x==0)
                {
                    r.set("Mike","man");                
                }
                else
                {
                    r.set("丽丽","女");
                }
            }
            x = (x+1)%2;            
        }
    }
}

class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {            
            synchronized(r)
            {    
                r.out();
            }            
        }
    }
}

class  ThreadCommunication
{
    public static void main(String[] args) 
    {
        Res r = new Res();
        Input in = new Input(r);
        Output out = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();
    }
}

当多个线程操作同一个资源，且同一个操作也有多个线程时，就需要使用while判断标记，并用notifyAll唤醒所有线程。

class FactoryDemo 
{
    public static void main(String[] args) 
    {
        Resource r = new Resource();
        Product pro = new Product(r);
        Consumer con = new Consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Product implements Runnable
{
    private Resource r = new Resource();
    Product(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            r.set("商品");
        }        
    }
}

class Consumer implements Runnable
{
    private Resource r = new Resource();
    Consumer(Resource r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            r.out();
        }        
    }
}

class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    public synchronized void set(String name)
    {
        while (flag)//使用while判断标记，避免线程在判断标记之后醒了不判断标记
        {
            try
            {
                this.wait();
            }
            catch (Exception e)
            {
            }
        }
        this.name = name + "--" + count++;
        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
        flag = true;
        this.notifyAll();
    }
    public synchronized void out()
    {
        while (!flag)//使用while判断标记，避免线程在判断标记之后醒了不从新判断标记
        {
            try
            {
                wait();
            }
            catch (Exception e)
            {
            }
        }
        System.out.println(Thread.currentThread().getName()+"...消费者.................."+this.name);
        flag = false;
        this.notifyAll();
    }
}

但notifyAll唤醒对方线程的同时也把本方的线程唤醒了，这是我们不希望看到的。对于该问题的优化，参见Lock接口