一.简介
在一般情况下,创建一个线程是不能提高程序的执行效率的,所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数,在多个线程同时对同一个内存地址进行写入,由于CPU时间调度上的问题,写入数据会被多次的覆盖,所以就要使线程同步。
线程同步:即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作, 其他线程才能对该内存地址进行操作,而其他线程又处于等待状态,目前实现线程同步的方法有很多,临界区对象就是其中一种。
二.线程同步的方式和机制
临界区、互斥量、事件、信号量四种方式
临界区(Critical Section)、互斥量(Mutex)、信号量(Semaphore)、事件(Event)的区别:
1、临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。在任意时刻只允许一个线程对共享资源 进行访问,如果有多个线程试图访问公共资源,那么在有一个线程进入后,其他试图访问公共资源的线程将被挂起,并一直等到进 入临界区的线程离开,临界区在被释放后,其他线程才可以抢占。
2、互斥量:采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限,因为互斥对象只有一个,所以能保证公共资源不 会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享,还能实现不同应用程序的公共资源安全共享。
3、信号量:它允许多个线程在同一时刻访问同一资源,但是需要限制在同一时刻访问此资源的最大线程数目。
4、事 件: 通过通知操作的方式来保持线程的同步,还可以方便实现对多个线程的优先级比较的操作。
三.synchronized
图例说明:因为线程t1和t2共用同一个对象timer,因此当两个线程同时访问的时候,就会因为不同线程对num的操作,造成不同步。
![](https://images2015.cnblogs.com/blog/1010726/201610/1010726-20161008234145629-1305861968.png)
示例代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } public void run() { timer.add(Thread.currentThread().getName()); } } class Timer { private static int num = 0; public void add(String name){ //public synchronized void add(String name){ //①表示执行当前方法过程中,锁定当前对象,是当前对象被锁定了 //synchronized(this){ //②表示锁定某一块东西 num++; try{ Thread.sleep(1); }catch(InterruptedException e){ } System.out.println(name+",你是第"+num+"个使用Timer的线程"); //} } }
此时结果是:
线程1,你是第2个使用Timer的线程
线程2,你是第2个使用Timer的线程
此时,可以用关键字synchronized通过线程的互斥来实现同步,
(提供了两种方法:①方法前加上synchronized;②synchronized(this){}):
放开注释的其中之一,此时结果是:
线程1,你是第1个使用Timer的线程
线程2,你是第2个使用Timer的线程
四.死锁
所谓死锁: 是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。
所以使用了synchronized关键字后,当几个线程共同竞争资源的时候就会产生死锁。如下例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class TestDeadLock implements Runnable{ public int flag = 0; static Object obj1 = new Object(); static Object obj2 = new Object(); public void setFlag(int flag){ this.flag = flag; } public static void main(String[] args) { TestDeadLock tdl1 = new TestDeadLock(); TestDeadLock tdl2 = new TestDeadLock(); tdl1.setFlag(0); tdl1.setFlag(1); Thread thread1 = new Thread(tdl1); Thread thread2 = new Thread(tdl2); thread1.start(); thread2.start(); } public void run() { System.out.println("flag="+flag); if(flag == 1){ synchronized(obj1){ //先申请资源1 try{ Thread.sleep(500); }catch(InterruptedException e){ e.printStackTrace(); } synchronized(obj2){ //后申请资源2 System.out.println("情况"+flag+"的资源申请完毕"); } } }else if(flag ==0){ synchronized(obj2){ //先申请资源2 try{ Thread.sleep(500); }catch(InterruptedException e){ e.printStackTrace(); } synchronized(obj1){ //后申请资源1 System.out.println("情况"+flag+"的资源申请完毕"); } } } } }
五.synchronized作用域
synchronized只会对使用了synchronized关键字的对象加锁,这样当被加锁对象正在访问时,另外的线程要对其进行访问才会互斥,未被加锁的对象不会产生互斥,即使都会用到同样的资源。因此要实现对某资源的同步就必须要把用到此资源的对象都加上synchronized关键字。如下例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class TestLockConcept implements Runnable{ int b = 100; //比如这是多处会用到的资源 public synchronized void m1() throws InterruptedException { b = 1000; Thread.sleep(2000); System.out.println("m1:b = " + b); } // public void m2() { // System.out.println("m2:b = " + b); //此时m2未加锁,m1加了锁,因此可以直接访问m2 // //结果: m2:b = 1000 m1:b = 1000 final:b = 1000 // } // public void m2() { // b = 2000; //此时m2未加锁,m1加了锁,也可以直接修改b和访问m2 // System.out.println("m2:b = " + b); // //结果: m2:b = 2000 m1:b = 2000 final:b = 2000 // } public synchronized void m2() throws InterruptedException { b = 2000; //此时m2加锁,m1也加了锁,不可以直接修改b和访问m2 System.out.println("m2:b = " + b); //结果: m1:b = 1000 m2:b = 2000 final:b = 2000 } public void run() { try{ m1(); }catch(InterruptedException e){ e.printStackTrace(); } } public static void main(String[] args) throws InterruptedException { TestLockConcept tl = new TestLockConcept(); Thread t = new Thread(tl); t.start(); Thread.sleep(1000); tl.m2(); Thread.sleep(2000); System.out.println("final:b = " + tl.b); } }
六.生产者和消费者
实例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class ProductConsumer { public static void main(String[] args) { SyncStack ss = new SyncStack(); Product p = new Product(ss); Consumer c = new Consumer(ss); //一个人每天生产40个馒头供四个人吃,每人吃十个。 new Thread(p).start(); new Thread(c).start(); new Thread(c).start(); new Thread(c).start(); new Thread(c).start(); } } class WoTou { //窝头即是资源,有人生产窝头,有人需要窝头。 int id; WoTou(int id){ this.id = id; } public String toString(){ return "wotou:" + id; } } class SyncStack { //装窝头的篮子,最多只能装6个,提供了往里放窝头以及从里面拿窝头的方法。 int index = 0; WoTou[] arrWT = new WoTou[6]; public synchronized void push(WoTou wt){ //往篮子里放窝头 while(index == arrWT.length){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } this.notifyAll(); arrWT[index] = wt; index++; System.out.println("生产了:" + wt); } public synchronized WoTou pop(){ //从篮子里面拿窝头 while(index == 0){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } this.notifyAll(); index--; WoTou wt = arrWT[index]; System.out.println("消费了:" + wt); return wt; } } class Product implements Runnable { SyncStack syncStack = null; Product(SyncStack syncStack) { this.syncStack = syncStack; } public void run() { for(int i=0;i<40;i++){ WoTou wt = new WoTou(i); syncStack.push(wt); try { Thread.sleep(200); //隔一阵子生产一个窝头 } catch (InterruptedException e) { e.printStackTrace(); } } } } class Consumer implements Runnable { SyncStack ss = null; Consumer(SyncStack ss) { this.ss = ss; } public void run() { for(int i=0;i<10;i++){ ss.pop(); try{ Thread.sleep(1000); //隔一阵子消费一个窝头 }catch(InterruptedException e){ e.printStackTrace(); } } } }
Stay hungry,stay foolish !