java中的并发:同步

目录
  1.安全问题的产生
  2.同步:synchronized
  3.并发中的三个概念
  4.happens-before原则
  5.修饰符:volatile

 

1.安全问题的产生

  如果我们想实现这样一个功能:利用线程并发模拟多个网点售同一种票.例:

Java代码  

1. public class ThreadDemo {  
2.   
3.     public static void main(String[] args) {  
4.         Ticket ticket = new Ticket();  
5.         new Thread(ticket).start();  
6.         new Thread(ticket).start();  
7.         new Thread(ticket).start();  
8.     }  
9. }  
10.   
11. class Ticket implements Runnable {  
12.     final Random r = new Random();  
13.     private int num = 10;  
14.   
15.     @Override  
16.     public void run() {  
17.         while (true) {  
18.             if (num > 0) {  
19.                 try {  
20.                     Thread.sleep(r.nextInt(100));  
21.                 } catch (InterruptedException e) {  
22.                 }  
23.                 System.out.println(Thread.currentThread().getName() + "..." + num--);  
24.             } else {  
25.                 break;  
26.             }  
27.         }  
28.     }  
29. }  

 

在运行结果中,输出了0和-1,一共买了12张票!
  由于每个线程执行的过程是不可控的,多个线程同时访问一个资源(本例中的num)时,会导致程序运行结果并不是想看到的结果,便会产生线程安全问题,这个资源被称为共享资源.

2.同步

  2.1synchronized
    基本上所有的并发模式在解决线程安全问题时,都采用"序列化访问临界资源"的方案,即同一时刻只能有一个线程访问共享资源,也称作同步互斥访问.通常是在访问临界资源的代码前面加上一个锁,当访问完临界资源后释放锁,让其他线程继续访问.java提供了synchronized关键字实现同步互斥访问,synchronized既可以修饰代码块,也可以用来修饰方法.
    每一个对象都拥有一个锁标记(monitor),也称为监视器,线程只有获取了该对象的锁才能访问.使用synchronized关键字来标记一个方法或者代码块,当某个线程调用该对象的synchronized方法或者访问synchronized代码块时,这个线程便获得了该对象的锁,其他线程暂时无法访问这个方法,只有等待这个方法执行完毕或者代码块执行完毕,这个线程才会释放该对象的锁,其他线程才能执行这个方法或者代码块.
  2.2同步块

Java代码  

1. public class ThreadDemo {  
2.   
3.     public static void main(String[] args) {  
4.         Ticket ticket = new Ticket();  
5.         new Thread(ticket).start();  
6.         new Thread(ticket).start();  
7.         new Thread(ticket).start();  
8.     }  
9. }  
10.   
11. class Ticket implements Runnable {  
12.     final Random r = new Random();  
13.     private int num = 10;  
14.     private Object obj=new Object();  
15.     @Override  
16.     public void run() {  
17.         while (true) {  
18.             synchronized(obj){  
19.                 if (num > 0) {  
20.                     try {  
21.                         Thread.sleep(r.nextInt(100));  
22.                     } catch (InterruptedException e) {  
23.                     }  
24.                     System.out.println(Thread.currentThread().getName() + "..."  
25.                             + num--);  
26.                 } else {  
27.                     break;  
28.                 }  
29.             }  
30.         }  
31.     }  
32. }  

 

 2.3同步方法

Java代码  

1. public class Test {  
2.   
3.     public static void main(String[] args) {  
4.         Ticket ticket = new Ticket();  
5.         new Thread(ticket).start();  
6.         new Thread(ticket).start();  
7.         new Thread(ticket).start();  
8.     }  
9. }  
10.   
11. class Ticket implements Runnable {  
12.     final Random r = new Random();  
13.     private int num = 10;  
14.     private boolean isEmpty = false;  
15.   
16.     @Override  
17.     public void run() {  
18.         while (!isEmpty) {  
19.             sell();  
20.         }  
21.     }  
22.   
23.     public synchronized void sell() {  
24.   
25.         if (num > 0) {  
26.             try {  
27.                 Thread.sleep(r.nextInt(100));  
28.             } catch (InterruptedException e) {  
29.             }  
30.             System.out  
31.                     .println(Thread.currentThread().getName() + "..." + num--);  
32.         } else {  
33.             isEmpty = true;  
34.         }  
35.     }  
36. }  

 

当一个线程正在访问一个对象的synchronized方法,那么其他线程不能访问该对象的其他synchronized方法,但是能访问该对象的非synchronized方法;如果一个线程A需要访问对象object1的synchronized方法fun1,另外一个线程B需要访问对象object2的synchronized方法fun1,即使object1和object2是同一类型,因为他们访问的是不同的对象,不会产生线程安全问题.同步方法是同步块的简写,效率相对较低.

2.4类的锁
    每个类也会有一个锁,它可以用来控制对static数据成员的并发访问.改进后线程安全的单例模式:

Java代码  

1. public class Single {  
2.   
3.     private static Single instance;  
4.   
5.     private Single() {  
6.     }  
7.   
8.     public static Single getInstance() {  
9.         if (instance == null) {// 解决了效率问题  
10.             synchronized (Test.class) {// 解决了并发安全  
11.                 if (instance == null) {  
12.                     instance = new Single();  
13.                 }  
14.             }  
15.         }  
16.         return instance;  
17.     }  
18. }  

 

3.并发中的三个概念

  3.1原子性    即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行.java内存模型只保证了基本读取和赋值是原子性操作.由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块,保证了大范围的原子性.
  3.2可见性
    当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值.java中通过volatile修饰的变量可以保证可见性.
  3.3有序性
    程序执行的顺序按照代码的先后顺序执行.
    指令重排序:处理器为了提高程序运行效率,可能会对输入代码进行优化,它不保证程序中各个语句的执行先后顺序同代码中的顺序一致,但是它会保证程序最终执行结果和代码顺序执行的结果是一致的.
    java内存模型具备一些先天的"有序性",不需要通过任何手段就能够得到保证的有序性,通常也称为 happens-before原则.如果两个操作的执行次序无法从happens-before原则推导出来,那么它们就不能保证它们的有序性,虚拟机可以随意地对它们进行重排序.

4.happens-before原则

  1)程序次序规则:一个线程内按照代码顺序,在前面的操作先行发生于在后面的操作
  2)锁定规则:一个unLock操作先行发生于后面对同一个锁的lock操作
  3)volatile变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作
  4)传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C
  5)线程启动规则:Thread对象的start()方法先行发生于此线程的每个一个动作
  6)线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
  7)线程终结规则:线程中所有的操作都先行发生于线程的终止检测,我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
  8)对象终结规则:一个对象的初始化完成先行发生于他的finalize()方法的开始

5.修饰符:volatile

  使用volatile修饰变量,保证其可见性并且禁止进行指令重排序.要实现线程安全必须保证变量是独立的,且对变量的操作是原子性的.volatile一般用于状态标志量.