JAVA之旅（十四）——静态同步函数的锁是class对象，多线程的单例设计模式，死锁，线程中的通讯以及通讯所带来的安全隐患，等待唤醒机制

一.静态同步函数的锁是class对象

我们在上节验证了同步函数的锁是this,但是对于静态同步函数，你又知道多少呢？

我们做一个这样的小实验，我们给show方法加上static关键字去修饰

private static synchronized void show() {        if (tick > 0) {            try {                Thread.sleep(10);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            System.out.println(Thread.currentThread() + "show:" + tick--);        }    }

然后我们来打印一下

发现他打印出0票了，说明他还是存在this隐患，同时也说明了一点就是他使用的锁不是this，那既然不是this，那是什么呢？

• 因为静态方法中，不可以定义this，我们可以分析，静态进内存中，内存中没有本类对象，但是一定有该类的字节码文件对象类名.class,我们可以这样同步

synchronized (MyThread.class)

你就会发现，线程是安全的了

静态同步的方法，使用的锁是该字节码的对象 类名.class

二.多线成中的单例设计模式

还记得我们讲的单例设计模式吗？我们今年温习一下这两个实现单例模式的方法

package com.lgl.hellojava;//公共的   类   类名public class HelloJJAVA {
        public static void main(String[] args) {        /**         * 单例设计模式         */    }}/** * 饿汉式 *  * @author LGL * */class Single1 {    private static final Single1 s = new Single1();    private Single1() {    }    public static Single1 getInstance() {        return s;    }}/** * 懒汉式 * @author LGL * */class Single {    private static Single s = null;    private Single() {    }    public static Single getInstance() {        if (s == null) {            s = new Single();        }        return s;    }}

我们着重点来看懒汉式，你会发现这个s是共享数据，所以我们所以延迟访问的话，一定会出现安全隐患的，但是我们使用synchronized来修饰的话，多线程启动每次都要判断有没有锁，势必会麻烦的，所以我们可以这样写

public static Single getInstance() {        if (s == null) {            synchronized (Single.class) {                if (s == null) {                    s = new Single();                }            }        }        return s;    }

这样其实是比较麻烦的，我们用饿汉式比较多，懒汉式作用是延时加载，多线成访问就会有安全问题

三.多线程的死锁

我们同步当中会产生一个问题，那就是死锁

• 同步中嵌套同步

是怎么个意思？我们来实现一下这段代码

package com.lgl.hellojava;//公共的   类   类名public class HelloJJAVA {
        public static void main(String[] args) {        /**         * 需求：简单的卖票程序，多个线程同时卖票         */        MyThread myThread = new MyThread();        Thread t1 = new Thread(myThread);        Thread t2 = new Thread(myThread);        t1.start();        try {            Thread.sleep(10);        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        myThread.flag = false;        t2.start();    }}/** * 卖票程序 *  * @author LGL * */class MyThread implements Runnable {    // 票数    private int tick = 100;    Object j = new Object();    boolean flag = true;    @Override    public void run() {        if (flag) {            while (true) {                synchronized (j) {                    show();                }            }        } else {            while (true) {                show();            }        }    }    private synchronized void show() {        synchronized (j) {            if (tick > 0) {                try {                    Thread.sleep(10);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                System.out.println(Thread.currentThread() + "show:" + tick--);            }        }    }}

这段代码里面，this锁中又object锁，object中又this锁，就会导致死锁，不信？我们运行一下

你会看到他会停止不动了，这就是死锁，而在我们开发中，我们应该尽量避免死锁的发生。

四.线程中的通讯

线程中的通讯，是比较重要的，我们看一下这张例图

存什么，取什么

线程中通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。我们来具体看看例子

package com.lgl.hellojava;//公共的   类   类名public class HelloJJAVA {
        public static void main(String[] args) {        /**         * 线程间通讯         */    }}// 资源class Res {
        String name;    String sex;}// 输入class Input implements Runnable {
        @Override    public void run() {    }}// 输出class Output implements Runnable {
        @Override    public void run() {    }}

我们定义这些个类，对吧，一个资源，两个操作，紧接着，我们应该怎么去操作他？

package com.lgl.hellojava;//公共的   类   类名public class HelloJJAVA {
        public static void main(String[] args) {        /**         * 线程间通讯         */        Res s = new Res();        Input in = new Input(s);        Output out = new Output(s);        Thread t1 = new Thread(in);        Thread t2 = new Thread(out);        t1.start();        t2.start();    }}// 资源class Res {
        String name;    String sex;}// 输入class Input implements Runnable {
        private Res s;    public Input(Res s) {        this.s = s;    }    @Override    public void run() {        int x = 0;        while (true) {            if (x == 0) {                s.name = "lgl";                s.sex = "男";            } else if (x == 1) {                s.name = "zhangsan";                s.sex = "女";            }            // 交替            x = (x + 1) % 2;        }    }}// 输出class Output implements Runnable {
        private Res s;    public Output(Res s) {        this.s = s;    }    @Override    public void run() {        while (true) {            System.out.println(s.name + "..." + s.sex);        }    }}

这样去操作，你看下输出，这里出现了一个有意思的现象

你回发现他输出的竟然有女，这就是存在了安全隐患，但是也进一步的证实了，线程间的通讯

五.线程通讯带来的安全隐患

我们线程通讯，会有安全隐患，那已经怎么去解决呢？我们是不是一来就想到了同步synchronized？其实这样做没用的， 因为你传的锁是不一样的，你要想让锁唯一，就类名.class

package com.lgl.hellojava;//公共的   类   类名public class HelloJJAVA {
        public static void main(String[] args) {        /**         * 线程间通讯         */        Res s = new Res();        Input in = new Input(s);        Output out = new Output(s);        Thread t1 = new Thread(in);        Thread t2 = new Thread(out);        t1.start();        t2.start();    }}// 资源class Res {
        String name;    String sex;}// 输入class Input implements Runnable {
        private Res s;    Object o = new Object();    public Input(Res s) {        this.s = s;    }    @Override    public void run() {        int x = 0;        while (true) {            synchronized (Input.class) {                if (x == 0) {                    s.name = "lgl";                    s.sex = "男";                } else if (x == 1) {                    s.name = "zhangsan";                    s.sex = "女";                }                // 交替                x = (x + 1) % 2;            }        }    }}// 输出class Output implements Runnable {
        private Res s;    public Output(Res s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (Input.class) {                System.out.println(s.name + "..." + s.sex);            }        }    }}

这样，就解决了问题了

六.多线程等待唤醒机制

我们不需要多线成高速消耗CPU，而是在适当的时候唤醒他，所以我们需要定义一个布尔值

package com.lgl.hellojava;//公共的   类   类名public class HelloJJAVA {
        public static void main(String[] args) {        /**         * 线程间通讯         */        Res s = new Res();        Input in = new Input(s);        Output out = new Output(s);        Thread t1 = new Thread(in);        Thread t2 = new Thread(out);        t1.start();        t2.start();    }}// 资源class Res {
        String name;    String sex;    boolean flag = false;}// 输入class Input implements Runnable {
        private Res s;    Object o = new Object();    public Input(Res s) {        this.s = s;    }    @Override    public void run() {        int x = 0;        while (true) {            synchronized (Input.class) {                if (s.flag) {                    try {                        // 等待线程都存放在线程池                        wait();                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                }                if (x == 0) {                    s.name = "lgl";                    s.sex = "男";                } else if (x == 1) {                    s.name = "zhangsan";                    s.sex = "女";                }                // 交替                x = (x + 1) % 2;                s.flag = true;                // 通知                notify();            }        }    }}// 输出class Output implements Runnable {
        private Res s;    public Output(Res s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (Input.class) {                if (!s.flag) {                    try {                        wait();                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                } else {                    System.out.println(s.name + "..." + s.sex);                    s.flag = false;                    notify();                }            }        }    }}

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

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

我们今天介绍就先到这里，线程的概念比较多，我们要写好几篇！！！

原文地址