我们对线程访问同一份资源的多个线程之间，来进行协调的这个东西，就是线程同步。
例子1：模拟了多个线程操作同一份资源，可能带来的问题：
package com.cy.thread; public class TestSync implements Runnable{ Timer timer = new Timer(); public static void main(String[] args) { TestSync test = new TestSync(); Thread t1 = new Thread(test); Thread t2 = new Thread(test); t1.setName("t1"); t2.setName("t2"); t1.start(); t2.start(); } @Override public void run() { timer.add(Thread.currentThread().getName()); } } class Timer{ private static int num = 0; public void add(String name){ num++; try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(name+",你是第"+num+"个使用timer的线程"); } }
两个线程访问的都是time对象；访问的都是time对象中的add方法；
但是console打印出来是：
为什么会出现上述问题呢？
解释：
第一个线程访问time对象的add方法，将num++，num变为1了；然后睡眠了；
这时候第二个线程开始执行，访问的仍然是同一份对象timer，肯定也是同一个num，num原来是1，执行num++，num变为2了；然后开始睡眠；
第一个线程醒过来了，num这时候是2，打印：t1,你是第2个使用timer的线程
第二个线程醒过来，打印：t2,你是第2个使用timer的线程
问题出在，这个线程在执行add这个方法的过程之中，被另外一个线程打断了；
num++;和
System.out.println(name+",你是第"+num+"个使用timer的线程");
这句话本来应该作为一个原子性的输出；你不能在中间给我打断了；
例子中写Thread.sleep(1)给另外一个线程执行的机会，方便看到效果；
但是即便是不写sleep(1),你很有可能看见的是正确的结果，但是当这个程序执行起来的过程之中，它还是有可能出问题；
中间还是有可能被打断；
怎么解决呢？
在执行
num++;
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name+",你是第"+num+"个使用timer的线程");
这句话的过程之中，请你把我当前的对象锁住就行了；
于是代码修改为：
class Timer{ private static int num = 0; public void add(String name){ synchronized (this) { num++; try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(name+",你是第"+num+"个使用timer的线程"); } } }
synchronized (this)：
锁定当前对象；在执行synchronized 后面大括号之间语句的过程之中，一个线程执行的过程之中，不会被另外一个线程打断；
一个线程已经进入到synchronized (this){}这个锁定的区域里面了，你放心，不可能有另外一个线程也在这里边；
既然锁定当前对象time了，它里面的成员变量num跟着也就锁定了；
这就是锁的机制；（互斥锁）
上面的还有一种简便的写法是这样的：
package com.cy.thread; public class TestSync implements Runnable{ Timer timer = new Timer(); public static void main(String[] args) { TestSync test = new TestSync(); Thread t1 = new Thread(test); Thread t2 = new Thread(test); t1.setName("t1"); t2.setName("t2"); t1.start(); t2.start(); } @Override public void run() { timer.add(Thread.currentThread().getName()); } } class Timer{ private static int num = 0; public synchronized void add(String name){ num++; try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(name+",你是第"+num+"个使用timer的线程"); } }
public synchronized void add(String name)相当于在执行这个方法的过程之中，锁定当前对象，锁定this；
是在执行这个方法的过程之中，当前对象被锁定；
分析现在的执行过程：
t1开始执行，调用add方法，num++，num变为1了，然后sleep，它睡着了没关系，睡着的时候还抱着这把锁呢。
别人进不来，你必须得等它执行完了，你才可以继续执行；
必须等它醒了，把
System.out.println(name+",你是第"+num+"个使用timer的线程");
这句话执行完了，另外一个线程才有执行的机会。
synchronized这个关键字会锁定某一段代码，它的内部的含义是当执行这段代码的过程之中，锁定当前对象；
另外一个人如果也想访问我这对象的话，他只能等着，等我这段代码执行完了，我的锁自然而然也就打开了。
你才能进的来。你才能访问我这对象；
二、当我们讲了锁之后，多线程还会带来其他的问题，一个典型的问题就是死锁。
死锁的原理：
死锁的原理：
当某一个线程执行的过程之中，需要锁定某个对象A，它已经把这个对象A锁住了；它还需要锁定另外的一个对象B，才能把整个操作执行完。
接下来另外一个线程，他也需要锁定两个对象，他首先锁定的是B；
第一个线程，它锁定了A，然后再拥有B对象的锁，它就能完成了；
第二个线程，他锁定了B，如果再能拥有A对象的锁，他就能完成了；
第一个线程锁定了A,但是执行不下去了，它等待的东西B被其他线程锁住了；
第二线程也执行不下去了，他等的东西A被另外的线程锁住了；
就是死锁了。
用程序来模拟：
package com.cy.thread; public class TestDeadLock implements Runnable{ public int flag = 1; static Object o1 = new Object(), o2 = new Object(); @Override public void run() { System.out.println("flag= " + flag); if(flag == 1){ synchronized (o1) { try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (o2) { System.out.println("1"); } } } if(flag == 0){ synchronized (o2) { try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (o1) { System.out.println("0"); } } } } public static void main(String[] args) { TestDeadLock td1 = new TestDeadLock(); TestDeadLock td2 = new TestDeadLock(); td1.flag = 1; td2.flag = 0; Thread t1 = new Thread(td1); Thread t2 = new Thread(td2); t1.start(); t2.start(); } }
程序一运行，打印
flag= 0
flag= 1
然后就死在那了...
解决线程死锁的问题：
你最好只锁住一个，不要锁住两，也就是把锁的粒度加粗一些；
锁定当前整个对象不就完了吗，干嘛锁定这个对象下面两个小对象啊。
把锁的粒度加粗一些，是办法之一，还有很多其他的办法...
三、生产者消费者问题
package com.cy.thread; public class ProducerConsumer { public static void main(String[] args) { SyncStack ss = new SyncStack(); Producer p = new Producer(ss); Consumer c = new Consumer(ss); new Thread(p).start(); new Thread(c).start(); } } /** * 馒头类 * id： 每一个馒头的id */ class WoTou{ int id; WoTou(int id){ this.id = id; } @Override public String toString() { return "WoTou : " + id; } } /** * 装馒头的篮子 用栈来模拟，先装进去的，最后拿出来 * 开始的时候装了0个馒头 * 一共能装arrWT.length = 6个馒头 */ class SyncStack{ int index = 0; WoTou[] arrWT = new WoTou[6]; /** * 装馒头 */ public synchronized void push(WoTou wt){ while(index == arrWT.length){ try { /** * 这里说的不是让当前对象wait；wait是指： * 锁定在我当前对象上的这个线程，停止住。注意： * wait方法只有你锁定了，锁定了我这个线程之后，才能wait，才有资格wait。 你要锁不住我这个对象就别谈wait这事。 * 如果这个方法不是synchronized的，调用wait立马出错。 * 而且一旦wait了，就死过去了，这个对象的锁就不再归我所有，只有在我醒过来的时候我才再找这把锁。 * （这是wait和sleep的巨大的区别） * * 一个线程访问我这个push方法的时候，它已经拿到我这个对象的锁了， * 拿到对象锁的这个线程在执行的过程之中，它遇到一个事件（已经满了，不能再往里装馒头了）必须阻塞住，必须停止， * 必须等清洁工把馒头清走了才能继续办事。所以目前只能等着。不能再生产了。 */ this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } /** * wait方法和notify方法一般是一一对应的 * notify：叫醒一个现正正在在wait在我这个对象上的线程。 * 谁现在正在我的对象上等待，我就叫醒一个线程，让它继续执行。 * notifyAll:叫醒等待在这个对象上的多个线程 * 例子中只有两个线程，用notify是可以的。 */ this.notify(); arrWT[index] = wt; index ++; } /** * 吃馒头 */ public synchronized WoTou pop(){ while(index==0){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } this.notify(); index --; return arrWT[index]; } } /** * 生产者 一次生产20个馒头 */ class Producer implements Runnable{ SyncStack ss = null; Producer(SyncStack ss){ this.ss = ss; } @Override public void run() { for(int i=0; i<20; i++){ WoTou wt = new WoTou(i); ss.push(wt); System.out.println("生产了: " + wt); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * 消费者 一次吃20个馒头 */ class Consumer implements Runnable{ SyncStack ss = null; Consumer(SyncStack ss){ this.ss = ss; } @Override public void run() { for(int i=0; i<20; i++){ WoTou wt = ss.pop(); System.out.println("消费了：" + wt); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } console打印： 生产了: WoTou : 0 消费了：WoTou : 0 生产了: WoTou : 1 消费了：WoTou : 1 生产了: WoTou : 2 消费了：WoTou : 2 生产了: WoTou : 3 消费了：WoTou : 3 生产了: WoTou : 4 消费了：WoTou : 4 生产了: WoTou : 5 消费了：WoTou : 5 生产了: WoTou : 6 消费了：WoTou : 6 消费了：WoTou : 7 生产了: WoTou : 7 生产了: WoTou : 8 消费了：WoTou : 8 生产了: WoTou : 9 消费了：WoTou : 9 生产了: WoTou : 10 消费了：WoTou : 10 生产了: WoTou : 11 消费了：WoTou : 11 生产了: WoTou : 12 消费了：WoTou : 12 消费了：WoTou : 13 生产了: WoTou : 13 生产了: WoTou : 14 消费了：WoTou : 14 生产了: WoTou : 15 消费了：WoTou : 15 生产了: WoTou : 16 消费了：WoTou : 16 生产了: WoTou : 17 消费了：WoTou : 17 生产了: WoTou : 18 消费了：WoTou : 18 消费了：WoTou : 19 生产了: WoTou : 19
--------------------------