Java 并发编程——同步与死锁

1. 同步与死锁

1.1 同步

说到线程，同步是一个不得不说的话题，为什么呢？因为多个线程访问同一资源时，如果不进行同步处理，那就会出问题。大家喜闻乐见的当然是卖票问题，如：

//源码：
public class ThreadByImplements_201810302136 implements Runnable{

    private int mTicket = 5;
    
    @Override
    public void run() {
        for (int i = 0; i < 25; i++) {
            if(mTicket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  " + (mTicket--));
            }
        }
    }
    
    public static void main(String[] args) {
        ThreadByImplements_201810302136 r1 = new ThreadByImplements_201810302136();
        Thread t1 = new Thread(r1,"THREAD-A-天王盖地虎");
        Thread t2 = new Thread(r1,"THREAD-B-宝塔镇河妖");
        Thread t3 = new Thread(r1,"THREAD-C-小鸡炖蘑菇");
        t1.start();
        t2.start();
        t3.start();
    }

}

//执行结果：
THREAD-A-天王盖地虎  3
THREAD-C-小鸡炖蘑菇  5
THREAD-B-宝塔镇河妖  4
THREAD-B-宝塔镇河妖  2
THREAD-A-天王盖地虎  2
THREAD-C-小鸡炖蘑菇  1
THREAD-B-宝塔镇河妖  0
THREAD-A-天王盖地虎  -1

其实简单分析一下就能明白为什么会出现上面的执行结果。在线程主体中，判断票数是否大于零，如果票数大于零，则卖，反之，则不卖。这样就会出现一种情况：票数为 1 的时候，一个线程刚把票买走，系统还没有来得及减，另外一个线程又进来了，由于系统此时还没有来得及减，所以此时票数还是大于零，结果后来的线程也买到票了。

要解决上面的问题，必须使用同步。所谓同步是指在同一时间段内，只能有一个线程对数据进行操作，其他线程只能等这个线程操作完之后才可以操作。

线程同步的方法有两种：同步代码块和同步方法。接下来，分别用两种方式对上面的例子进行处理。

1.1.1 同步代码块
1.1.1.1 语法
synchronized (同步对象) {
    //需要同步的代码块
}
1.1.1.2 实例
//源码：
public class ThreadByImplements_201810302208 implements Runnable {

    private int mTicket = 5;
    
    @Override
    public void run() {
        for (int i = 0; i < 25; i++) {
            synchronized (this) {
                if(mTicket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "  " + (mTicket--));
                }
            }
        }
    }
    
    public static void main(String[] args) {
        ThreadByImplements_201810302208 r1 = new ThreadByImplements_201810302208();
        Thread t1 = new Thread(r1,"THREAD-A-天王盖地虎");
        Thread t2 = new Thread(r1,"THREAD-B-宝塔镇河妖");
        Thread t3 = new Thread(r1,"THREAD-C-小鸡炖蘑菇");
        t1.start();
        t2.start();
        t3.start();
    }

}

//执行结果：
THREAD-A-天王盖地虎  5
THREAD-A-天王盖地虎  4
THREAD-A-天王盖地虎  3
THREAD-A-天王盖地虎  2
THREAD-A-天王盖地虎  1
1.1.2 同步方法
1.1.2.1 语法
synchronized 方法返回值 方法名(参数列表){}
1.1.2.2 实例
//源码：
public class ThreadByImplements_201810302220 implements Runnable {

    private int mTicket = 5;
    
    @Override
    public void run() {
        for (int i = 0; i < 25; i++) {
            saleTicket();
        }
    }
    
    private synchronized void saleTicket(){
        if(mTicket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "  " + (mTicket--));
        }
    }
    
    public static void main(String[] args) {
        ThreadByImplements_201810302220 r1 = new ThreadByImplements_201810302220();
        Thread t1 = new Thread(r1,"THREAD-A-天王盖地虎");
        Thread t2 = new Thread(r1,"THREAD-B-宝塔镇河妖");
        Thread t3 = new Thread(r1,"THREAD-C-小鸡炖蘑菇");
        t1.start();
        t2.start();
        t3.start();
    }

}

//执行结果：
THREAD-A-天王盖地虎  5
THREAD-A-天王盖地虎  4
THREAD-A-天王盖地虎  3
THREAD-A-天王盖地虎  2
THREAD-A-天王盖地虎  1

1.2 死锁

同步解决了资源共享时数据错乱的问题，但并不代表同步处理越多越好。例如，周五的时候，你和女票在家做了一顿饭。吃完饭，女票让你刷锅，你让女票打扫卫生。小仙女可不想打扫卫生，于是说：“等你刷完锅，我就开始打扫卫生”。你一眼识破了女票诡计，于是也说了句：“等你扫完地，我就开始刷锅”。就这样，到了第二天，你们的锅还没有刷，卫生还没有打扫，这实际上就是死锁的概念。

所谓死锁是指两个线程在等待对方先执行完，造成了程序的停滞。接下来就根据上面例子的示范一下，死锁是如何出现的：

//源码：
public class ThreadByImplements_201810302344 implements Runnable {

    //由于是两个 Runnable 对象，所以必须使用静态成员变量才能实现资源共享
    private static GirlFriend gf = new GirlFriend();
    private static BoyFriend bf = new BoyFriend();
    private boolean speakFirst = false;
    
    @Override
    public void run() {
        if(speakFirst){
            synchronized (gf) {
                //1.先下手为强
                gf.say();
                try {
                    //2.等待对方刷碗
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (bf) {
                    //3.对方刷完碗，自己开始打扫卫生
                    gf.clean();
                }
            }
        }else{
            synchronized (bf) {
                //a.以其人之道，还治其人之身
                bf.say();
                try {
                    //b.等待对方打扫卫生
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (gf) {
                    //c.对方打扫完卫生，自己开始刷锅
                    bf.wash();
                }
            }
        }
    }

    public static void main(String[] args) {
        ThreadByImplements_201810302344 gfRunnable = new ThreadByImplements_201810302344();
        ThreadByImplements_201810302344 bfRunnable = new ThreadByImplements_201810302344();
        gfRunnable.speakFirst = true;
        bfRunnable.speakFirst = false;
        Thread gfThread = new Thread(gfRunnable);
        Thread bfThread = new Thread(bfRunnable);
        gfThread.start();
        bfThread.start();
    }

}

class GirlFriend {
    
    public void say(){
        System.out.println("女生对男生说：你先刷锅，我再打扫卫生");
    }
    
    public void clean(){
        System.out.println("女生开始打扫卫生");
    }
    
}

class BoyFriend {
    
    public void say(){
        System.out.println("男生对女生说：你先打扫卫生，我再刷锅");
    }
    
    public void wash(){
        System.out.println("男生开始刷锅");
    }
    
}

//执行结果：
女生对男生说：你先刷锅，我再打扫卫生
男生对女生说：你先打扫卫生，我再刷锅
//后面代码不再执行，程序进入死锁状态

程序最终执行效果就是下面这个样子：

image

1.3 相关问题

1.3.1 两种创建线程的方式均能实现资源共享吗？如果能，怎么做？如果不能，为什么？
1.3.1.1 继承 Thread 类

通过继承 Thread 实现线程时，Thread 子类中定义的普通变量不可共享，静态变量可共享，但此时存在“资源共享，但不同步”问题。

接下来，对以下几种情况进行详细分析：

序号 处理方式
1 定义普通变量
2 定义普通变量，并通过 synchronized 关键字同步当前对象
3 定义静态变量
4 定义静态变量，并通过 synchronized 关键字同步当前对象

1.3.1.1.1 定义普通变量

//源码：
//
//第一种方式：定义普通变量（不做任何处理）
//结论：资源不共享

1.3.1.1.2 定义普通变量，并通过 synchronized 关键字同步当前对象

//源码：
public class ThreadByExtend_201809072104 extends Thread {

    private int bandit = 5;
    
    public ThreadByExtend_201809072104() {}
    
    public ThreadByExtend_201809072104(String n) {
        super(n);
    }
    
    @Override
    public void run() {
    
        for (int i = 0; i < 25; i++) {
            synchronized (this) {
                if (bandit > 0) {
                    System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
                }
            }
        }
        
    }
    
    public static void main(String[] args) {
        ThreadByExtend_201809072104 t1 = new ThreadByExtend_201809072104("THREAD-张飞");
        ThreadByExtend_201809072104 t2 = new ThreadByExtend_201809072104("THREAD-赵云");
        ThreadByExtend_201809072104 t3 = new ThreadByExtend_201809072104("THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
    }

}

//执行结果：
THREAD-张飞  杀了  5  土匪  1584869782
THREAD-张飞  杀了  4  土匪  1584869782
THREAD-张飞  杀了  3  土匪  1584869782
THREAD-张飞  杀了  2  土匪  1584869782
THREAD-赵云  杀了  5  土匪  1751905002
THREAD-赵云  杀了  4  土匪  1751905002
THREAD-赵云  杀了  3  土匪  1751905002
THREAD-吕布  杀了  5  土匪  736376815
THREAD-吕布  杀了  4  土匪  736376815
THREAD-吕布  杀了  3  土匪  736376815
THREAD-赵云  杀了  2  土匪  1751905002
THREAD-张飞  杀了  1  土匪  1584869782
THREAD-赵云  杀了  1  土匪  1751905002
THREAD-吕布  杀了  2  土匪  736376815
THREAD-吕布  杀了  1  土匪  736376815

//第二种方式：定义普通变量，并通过 synchronized 关键字同步当前对象
//结论：资源不共享
//synchronized 关键字的主要作用是同步，而同步的前提是资源共享，所以，此处的同步处理完全是没必要的

1.3.1.1.3 定义静态变量

//源码：
public class ThreadByExtend_201809072104 extends Thread {

    private static int bandit = 5;
    
    public ThreadByExtend_201809072104() {}
    
    public ThreadByExtend_201809072104(String n) {
        super(n);
    }
    
    @Override
    public void run() {
    
        for (int i = 0; i < 25; i++) {
            if (bandit > 0) {
                System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
            }
        }
        
    }
    
    public static void main(String[] args) {
        ThreadByExtend_201809072104 t1 = new ThreadByExtend_201809072104("THREAD-张飞");
        ThreadByExtend_201809072104 t2 = new ThreadByExtend_201809072104("THREAD-赵云");
        ThreadByExtend_201809072104 t3 = new ThreadByExtend_201809072104("THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
    }

}

//执行结果：
THREAD-赵云  杀了  5  土匪  576357660
THREAD-赵云  杀了  2  土匪  576357660
THREAD-赵云  杀了  1  土匪  576357660
THREAD-吕布  杀了  3  土匪  1584869782
THREAD-张飞  杀了  4  土匪  366287508

//第三种方式：定义静态变量
//结论：达到资源共享的目的，但存在“资源共享，但不同步”问题

1.3.1.1.4 定义静态变量，并通过 synchronized 关键字同步当前对象

//源码：
public class ThreadByExtend_201809072104 extends Thread {

    private static int bandit = 5;
    
    public ThreadByExtend_201809072104() {}
    
    public ThreadByExtend_201809072104(String n) {
        super(n);
    }
    
    @Override
    public void run() {
    
        for (int i = 0; i < 25; i++) {
            synchronized (this) {
                if (bandit > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
                }
            }
        }
        
    }
    
    public static void main(String[] args) {
        ThreadByExtend_201809072104 t1 = new ThreadByExtend_201809072104("THREAD-张飞");
        ThreadByExtend_201809072104 t2 = new ThreadByExtend_201809072104("THREAD-赵云");
        ThreadByExtend_201809072104 t3 = new ThreadByExtend_201809072104("THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
    }

}

//执行结果：
THREAD-吕布  杀了  5  土匪  1584869782
THREAD-赵云  杀了  4  土匪  576357660
THREAD-张飞  杀了  5  土匪  366287508
THREAD-赵云  杀了  3  土匪  576357660
THREAD-吕布  杀了  3  土匪  1584869782
THREAD-张飞  杀了  2  土匪  366287508
THREAD-赵云  杀了  1  土匪  576357660
THREAD-吕布  杀了  -1  土匪  1584869782
THREAD-张飞  杀了  0  土匪  366287508

//第四种方式：定义静态变量，并通过 synchronized 关键字同步当前对象（验证第三种方式提到的问题）
//结论：未解决“资源共享，但不同步”问题
1.3.1.2 实现 Runnable 接口

通过实现 Runnable 接口实现线程时，可以方便地实现资源共享，但此时的“资源共享、同步”存在倾斜性。

接下来，对以下几种情况进行详细分析：

序号 处理方式
1 定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源共享）
2 定义普通变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源共享）
3 定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源同步）
4 定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证 Synchronized 关键字）
5 定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源共享）
6 定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源共享）
7 定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源同步）
8 定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源同步）
9 定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证 Synchronized 关键字）
10 定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证 Synchronized 关键字）

1.3.1.2.1 定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源共享）

//源码
public class ThreadByImplement_201809072056 implements Runnable {

    private int bandit = 5;
    
    @Override
    public void run() {
        for (int i = 0; i < 25; i++) {
            if (bandit > 0) {
                System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
            }
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r1,"THREAD-赵云");
        Thread t3 = new Thread(r1,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果
THREAD-赵云  杀了  5  土匪  1008269275
THREAD-赵云  杀了  2  土匪  1008269275
THREAD-张飞  杀了  4  土匪  1008269275
THREAD-吕布  杀了  3  土匪  1008269275
THREAD-赵云  杀了  1  土匪  1008269275

//第一种方式：定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源共享）
//结论：资源共享

1.3.1.2.2 定义普通变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源共享）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private int bandit = 5;
    
    @Override
    public void run() {
        for (int i = 0; i < 25; i++) {
            if (bandit > 0) {
                System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
            }
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r2 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r3 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r2,"THREAD-赵云");
        Thread t3 = new Thread(r3,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-张飞  杀了  5  土匪  366287508
THREAD-张飞  杀了  4  土匪  366287508
THREAD-张飞  杀了  3  土匪  366287508
THREAD-赵云  杀了  5  土匪  576357660
THREAD-赵云  杀了  4  土匪  576357660
THREAD-赵云  杀了  3  土匪  576357660
THREAD-吕布  杀了  5  土匪  1584869782
THREAD-赵云  杀了  2  土匪  576357660
THREAD-赵云  杀了  1  土匪  576357660
THREAD-张飞  杀了  2  土匪  366287508
THREAD-张飞  杀了  1  土匪  366287508
THREAD-吕布  杀了  4  土匪  1584869782
THREAD-吕布  杀了  3  土匪  1584869782
THREAD-吕布  杀了  2  土匪  1584869782
THREAD-吕布  杀了  1  土匪  1584869782

//第二种方式：定义普通变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源共享）
//结论：资源不共享

1.3.1.2.3 定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源同步）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private int bandit = 5;
    
    @Override
    public void run() {
        if (bandit > 0) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r1,"THREAD-赵云");
        Thread t3 = new Thread(r1,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-赵云  杀了  4  土匪  1584869782
THREAD-吕布  杀了  3  土匪  1584869782
THREAD-张飞  杀了  5  土匪  1584869782
THREAD-吕布  杀了  2  土匪  1584869782
THREAD-张飞  杀了  2  土匪  1584869782
THREAD-赵云  杀了  1  土匪  1584869782
THREAD-张飞  杀了  0  土匪  1584869782
THREAD-吕布  杀了  -1  土匪  1584869782

//第三种方式：定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源同步）
//结论：资源共享，但不同步

1.3.1.2.4 定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证 Synchronized 关键字）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private int bandit = 5;
    
    @Override
    public void run() {
        synchronized (this) {
            if (bandit > 0) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
            }
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r1,"THREAD-赵云");
        Thread t3 = new Thread(r1,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-张飞  杀了  5  土匪  576357660
THREAD-张飞  杀了  4  土匪  576357660
THREAD-张飞  杀了  3  土匪  576357660
THREAD-张飞  杀了  2  土匪  576357660
THREAD-张飞  杀了  1  土匪  576357660

//第四种方式：定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证 Synchronized 关键字）
//结论：Synchronized 成功解决“资源共享，但不同步”问题

此处能解决“资源共享，但不同步”问题，主要原因是保证了在同一时间段内，只能有一个线程对数据进行操作。

1.3.1.2.5 定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源共享）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private static int bandit = 5;
    
    @Override
    public void run() {
        if (bandit > 0) {
            System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r1,"THREAD-赵云");
        Thread t3 = new Thread(r1,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-赵云  杀了  4  土匪  366287508
THREAD-赵云  杀了  2  土匪  366287508
THREAD-赵云  杀了  1  土匪  366287508
THREAD-吕布  杀了  5  土匪  366287508
THREAD-张飞  杀了  3  土匪  366287508

//第五种方式：定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源共享）
//结论：资源共享

1.3.1.2.6 定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源共享）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private static int bandit = 5;
    
    @Override
    public void run() {
        if (bandit > 0) {
            System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r2 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r3 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r2,"THREAD-赵云");
        Thread t3 = new Thread(r3,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-赵云  杀了  4  土匪  576357660
THREAD-赵云  杀了  2  土匪  576357660
THREAD-张飞  杀了  3  土匪  366287508
THREAD-吕布  杀了  5  土匪  1584869782
THREAD-赵云  杀了  1  土匪  576357660

//第六种方式：定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源共享）
//结论：资源共享

1.3.1.2.7 定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源同步）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private static int bandit = 5;
    
    @Override
    public void run() {
        if (bandit > 0) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r1,"THREAD-赵云");
        Thread t3 = new Thread(r1,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-赵云  杀了  3  土匪  1578680387
THREAD-张飞  杀了  5  土匪  1578680387
THREAD-吕布  杀了  4  土匪  1578680387
THREAD-张飞  杀了  2  土匪  1578680387
THREAD-吕布  杀了  2  土匪  1578680387
THREAD-赵云  杀了  2  土匪  1578680387
THREAD-赵云  杀了  1  土匪  1578680387
THREAD-吕布  杀了  -1  土匪  1578680387
THREAD-张飞  杀了  0  土匪  1578680387

//第七种方式：定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证资源同步）
//结论：资源共享，但不同步

1.3.1.2.8 定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源同步）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private static int bandit = 5;
    
    @Override
    public void run() {
        if (bandit > 0) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r2 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r3 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r2,"THREAD-赵云");
        Thread t3 = new Thread(r3,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-吕布  杀了  4  土匪  1751905002
THREAD-张飞  杀了  5  土匪  576357660
THREAD-赵云  杀了  3  土匪  1584869782
THREAD-吕布  杀了  1  土匪  1751905002
THREAD-赵云  杀了  2  土匪  1584869782
THREAD-张飞  杀了  2  土匪  576357660

//第八种方式：定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证资源同步）
//结论：资源共享，但不同步

1.3.1.2.9 定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证 Synchronized 关键字）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private static int bandit = 5;
    
    @Override
    public void run() {
        synchronized (this) {
            if (bandit > 0) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
            }
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r1,"THREAD-赵云");
        Thread t3 = new Thread(r1,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-张飞  杀了  5  土匪  366287508
THREAD-张飞  杀了  4  土匪  366287508
THREAD-张飞  杀了  3  土匪  366287508
THREAD-张飞  杀了  2  土匪  366287508
THREAD-张飞  杀了  1  土匪  366287508

//第九种方式：定义静态变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证 Synchronized 关键字）
//结论：Synchronized 成功解决“资源共享，但不同步”问题

此处能解决“资源共享，但不同步”问题，和《5.3.1.2.4 定义普通变量，只创建一个 Runnable 实现类，不同的 Thread 使用同一个 Runnable 实现类（验证 Synchronized 关键字）》原因一样——保证了在同一时间段内，只能有一个线程对数据进行操作。

1.3.1.2.10 定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证 Synchronized 关键字）

//源码：
public class ThreadByImplement_201809072056 implements Runnable {

    private static int bandit = 5;
    
    @Override
    public void run() {
        synchronized (this) {
            if (bandit > 0) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  杀了  " + (bandit--) + "  土匪  " + this.hashCode());
            }
        }
    }

    public static void main(String[] args) {
    
        ThreadByImplement_201809072056 r1 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r2 = new ThreadByImplement_201809072056();
        ThreadByImplement_201809072056 r3 = new ThreadByImplement_201809072056();
        Thread t1 = new Thread(r1,"THREAD-张飞");
        Thread t2 = new Thread(r2,"THREAD-赵云");
        Thread t3 = new Thread(r3,"THREAD-吕布");
        t1.start();
        t2.start();
        t3.start();
        
    }

}

//执行结果：
THREAD-赵云  杀了  4  土匪  736376815
THREAD-吕布  杀了  5  土匪  443403783
THREAD-张飞  杀了  3  土匪  1751905002
THREAD-赵云  杀了  2  土匪  736376815
THREAD-吕布  杀了  1  土匪  443403783
THREAD-张飞  杀了  0  土匪  1751905002
THREAD-赵云  杀了  -1  土匪  736376815

//第十种方式：定义静态变量，创建三个 Runnable 实现类，不同的 Thread 使用不同的 Runnable 实现类（验证 Synchronized 关键字）
//结论：Synchronized 未能解决“资源共享，但不同步”问题

综合以上分析，可得：在实际开发中，如果用到线程并涉及资源共享，通过实现 Runnable 接口的方式来实现线程是一个不错的选择。

1.3.2 Synchronized 关键字都能修饰哪些元素（代码块、方法、类）？

Synchronized 关键字可以修饰代码块和方法，不能修饰类，如：

//源码：
public class ThreadByImplements_201810312214 implements Runnable {

    private int mTicket = 5;
    
    @Override
    public void run() {
        for (int i = 0; i < 25; i++) {
            saleTickets();
            saleTickets1();
        }
    }

    public static void main(String[] args) {
        ThreadByImplements_201810312214 r1 = new ThreadByImplements_201810312214();
        Thread t1 = new Thread(r1,"THREAD-A-天王盖地虎");
        Thread t2 = new Thread(r1,"THREAD-B-宝塔镇河妖");
        Thread t3 = new Thread(r1,"THREAD-C-小鸡炖蘑菇");
        t1.start();
        t2.start();
        t3.start();
    }

    private void saleTickets(){
        synchronized (this) {
            if(mTicket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  " + (mTicket--));
            }
        }
    }
    
    private synchronized void saleTickets1(){
        synchronized (this) {
            if(mTicket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  " + (mTicket--));
            }
        }
    }
    
}

//执行结果：
THREAD-A-天王盖地虎  5
THREAD-A-天王盖地虎  4
THREAD-A-天王盖地虎  3
THREAD-A-天王盖地虎  2
THREAD-A-天王盖地虎  1

在上面的示例中，如果在 class 前面添加 Synchronized 关键字，开发工具会提示：Illegal modifier for the class ThreadByImplements_201810312214; only public, abstract & final are permitted，而代码块和方法是可以用 Synchronized 关键字修饰的。

参考文档

1）《Java 开发实战经典》
2）《Thinking in Java》
3）Android Developer Document
4）Java Tutorials

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 200,302评论 5赞 470
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 84,232评论 2赞 377
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 147,337评论 0赞 332
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 53,977评论 1赞 272
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 62,920评论 5赞 360
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,194评论 1赞 277
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,638评论 3赞 390
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,319评论 0赞 254
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,455评论 1赞 294
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,379评论 2赞 317
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,426评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,106评论 3赞 315
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,696评论 3赞 303
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,786评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,996评论 1赞 255
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,467评论 2赞 346
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,043评论 2赞 341