本篇本章主要介绍以synchronized关键字的方式实现线程同步，以及线程间的通信。
为什么要用线程同步####
我们先来看下这段代码的运行结果：
package com.Dan;
public class TestRunnable {
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread t1 = new Thread( myThread, "1 号售票窗口");
Thread t2 = new Thread( myThread, "2 号售票窗口");
Thread t3 = new Thread( myThread, "3 号售票窗口");
t1.start();
t2.start();
t3.start();
}
}
class MyThread implements Runnable{
private int ticket = 90; // 90张票
private String ticketWindowName; // 售票窗口
@Override
public void run(){
for(int i = 0;i < 100; i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(this.ticket>0){
System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.ticket--));
}
}
}
}
// 1 号售票窗口卖票---->90
// 3 号售票窗口卖票---->88
// 2 号售票窗口卖票---->89
// 2 号售票窗口卖票---->87
// 1 号售票窗口卖票---->87
// 3 号售票窗口卖票---->87
// 2 号售票窗口卖票---->86
// 87 那张票被三个窗口各卖了一次，想下那个画面，火车上一个位子三个人坐。
在多线程上篇博客已经介绍过了，JVM采用的是抢占式调度模型，当一个线程sleep的时候，其它线程会抢占CPU资源。如果发生在数据库中，就是“脏读”。synchronized锁就是用来解决这个问题的，多线程的线程同步机制实际上是靠锁的概念来控制的。
第一种方式：synchronized关键字修饰函数方法####
// 修改run方法
@Override
public synchronized void run(){
for(int i = 0;i < 100; i++){
if(this.ticket>0){
System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.ticket--));
notifyAll();
}
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 1 号售票窗口卖票---->90
// 3 号售票窗口卖票---->89
// 2 号售票窗口卖票---->88
// 3 号售票窗口卖票---->87
// 1 号售票窗口卖票---->86
// 2 号售票窗口卖票---->85
// 3 号售票窗口卖票---->84
// 1 号售票窗口卖票---->83
// 关于notify和wait的用法参考多线程（三）
第二种方式：synchronized关键字修饰代码块####
public void run() {
for (int i = 0; i < 100; i++) {
synchronized (this) {
if (this.ticket > 0) {
System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.ticket--));
notifyAll();
}
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
// 1 号售票窗口卖票---->90
// 2 号售票窗口卖票---->89
// 1 号售票窗口卖票---->88
// 3 号售票窗口卖票---->87
// 1 号售票窗口卖票---->86
// 2 号售票窗口卖票---->85
// 3 号售票窗口卖票---->84
// 1 号售票窗口卖票---->83
多个对象多个锁的情况####
三个线程同时进行，每个线程只打印一个字母，交替打印ABCABC...
package com.Dan;
class MyThread2 implements Runnable {
private Object prev;
private Object self;
public MyThread2(Object prev, Object self) {
this.prev = prev;
this.self = self;
}
@Override
public void run() {
int ticket = 8; // 打印8次
while (ticket > 0) {
synchronized (prev) {
synchronized (self) {
System.out.print(Thread.currentThread().getName());
ticket--;
self.notify();
}
try {
prev.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Object a = new Object();
Object b = new Object();
Object c = new Object();
MyThread2 myThread1 = new MyThread2(c, a);
MyThread2 myThread2 = new MyThread2(a, b);
MyThread2 myThread3 = new MyThread2(b, c);
new Thread(myThread1, "A").start();
Thread.sleep(100);
new Thread(myThread2, "B").start();
Thread.sleep(100);
new Thread(myThread3, "C").start();
Thread.sleep(100);
}
}
// ABCABCABCABCABCABCABCABC
prev代表前一个对象，self代表自身。线程先持有前一个对象的锁和本次要打印的对象的锁，执行打印，然后唤醒一个正在等待当前对象锁的线程（剩下的那个线程），并让它拿到对象锁。prev.wait()方法让本线程进入等待状态，让本线程休眠，线程自动释放其占有的对象锁，并等待notify。如此循环反复打印8次ABC。
总结一下####
- 当多个线程访问同一对象的时候，只能有一个线程取得对象的锁，多个对象需要多个对象的锁。
- 这里锁住的是当前对象，并不是方法。哪个线程执行了带synchronized关键字的方法，哪个线程就持有该方法所属对象的锁，其他的线程要访问这个对象锁内的内容，都只能等待这个锁被释放后，再去抢占资源获得对象的锁。
- synchronized修饰非static的方法时，锁的就是对象本身，也就是this。
- synchronized修饰static的方法时，方法中无法使用this，所以它锁的不是this，而是这个类。所以，static synchronized方法也相当于全局锁。
- 使用synchronized关键字，应尽量缩小代码块的范围，最好能在代码块上加同步，而不是在整个方法上加同步。因为你锁的范围大的话，时间又长，别的线程就不会获得相应的资源。
- A线程持有对象的锁，B线程可以以异步方式调用对象中的非synchronized同步的方法。
写完喽！ㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏ
纸上得来终觉浅，绝知此事要躬行。——陆游
问渠那得清如许，为有源头活水来。——朱嘉
欢迎转载，转载请注明出处！
如果有错误的地方，或者有您的见解，还请不啬赐教！
喜欢的话，麻烦点个赞！
