我们对线程访问同一份资源的多个线程之间，来进行协调的这个东西，就是线程同步。
例子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
--------------------------