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