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

作者: 极速24号 | 来源:发表于2018-11-03 10:44 被阅读11次

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

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

1. 同步与死锁

1.1 同步

1.1.1 同步代码块

1.1.1.1 语法

1.1.1.2 实例

1.1.2 同步方法

1.1.2.1 语法

1.1.2.2 实例

1.2 死锁

1.3 相关问题

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

1.3.1.1 继承 Thread 类

1.3.1.2 实现 Runnable 接口

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

参考文档

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java 基础概念