程序博客网 > 下载行者软件

java线程安全

来源：互联网 发布：下载行者软件 编辑：程序博客网 时间：2024/06/05 13:22

转载http://blog.csdn.net/yangaming/article/details/8634806

java的线程安全的问题：其实就是控制多个线程对某个资源的有序访问或者修改。

java的内存模型主要是解决两个问题：（1）可见性（2）有序性

（1）可见性：多个线程之间是不能相互传递数据通信的，他们之间只能通过共享变量来进行沟通。java的内存模型规定了jvm有主存，主存是多个线程共享的。当new一个对象的时候，也是被分配在主存当中，每个线程都有自己的工作内存，工作线程存储了主存的某些对象的副本，淡然县城的工作内存大小是有限制的。

当线程操作某个对象的时候，执行的顺序如下：

（1）从主存复制变量到当前工作内存（read and load）

（2）执行代码，改变共享变量值（use and assign ）

（3）用工作内存的数据刷新主存的相关内容（store and write)


(3) 用工作内存数据刷新主存相关内容 (store and write)

JVM规范定义了线程对主存的操作指令：read，load，use，assign，store，write。当一个共享变量在多个线程的工作

内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。

(2)有序性：线程在引用变量的时候不能直接从主存中引用，如果线程的工作内存中没有改变量，则会从主存中拷贝一个副本到工作内存中。这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段的时候，有可能重新从主存中获取变量的副本（read-load-use），也有可能直接引用原来的副本(use).也就是说read/load/use顺序可以由Jvm实现系统决定。线程不能直接为主存中的字段赋值，它会将值指定给工作内存中的变量副本（assign）,

完成后这个变量副本会同步到主存储区(store-write)，至于何时同步过去，根据JVM实现系统决定.有该字段,则会从主

内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本，

当同一线程多次重复对字段赋值时,比如：

[java] view plain copy
  1. for(int i=0;i<10;i++)     
  2.      a++;  

线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区，所以assign,store,weite顺序

可以由JVM实现系统决定。假设有一个共享变量x，线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个

原子操作，它的执行过程如下

1 从主存中读取变量x副本到工作内存 
2 给x加1 
3 将x加1后的值写回主存

如果另外一个线程b执行x=x-1，执行过程如下： 

1 从主存中读取变量x副本到工作内存 
2 给x减1 
3 将x减1后的值写回主

那么显然，最终的x的值是不可靠的。假设x现在为10，线程a加1，线程b减1，从表面上看，似乎最终x还是为10，

但是多线程情况下会有这种情况发生：

1：线程a从主存读取x副本到工作内存，工作内存中x值为10 
2：线程b从主存读取x副本到工作内存，工作内存中x值为10 
3：线程a将工作内存中x加1，工作内存中x值为11 
4：线程a将x提交主存中，主存中x为11 
5：线程b将工作内存中x值减1，工作内存中x值为9 
6：线程b将x提交到中主存中，主存中x为9 

同样，x有可能为11，如果x是一个银行账户，线程a存款，线程b扣款，显然这样是有严重问题的，要解决这个问题，

必须保证线程a和线程b是有序执行的，并且每个线程执行的加1或减1是一个原子操作。看看下面代码：

[java] view plain copy
  1. public class Account {    
  2.     
  3.     private int balance;    
  4.     
  5.     public Account(int balance) {    
  6.         this.balance = balance;    
  7.     }    
  8.     
  9.     public int getBalance() {    
  10.         return balance;    
  11.     }    
  12.     
  13.     public void add(int num) {    
  14.         balance = balance + num;    
  15.     }    
  16.     
  17.     public void withdraw(int num) {    
  18.         balance = balance - num;    
  19.     }    
  20.     
  21.     public static void main(String[] args) throws InterruptedException {    
  22.         Account account = new Account(1000);    
  23.         Thread a = new Thread(new AddThread(account, 20), "add");    
  24.         Thread b = new Thread(new WithdrawThread(account, 20), "withdraw");    
  25.         a.start();    
  26.         b.start();    
  27.         a.join();    
  28.         b.join();    
  29.         System.out.println(account.getBalance());    
  30.     }    
  31.     
  32.     static class AddThread implements Runnable {    
  33.         Account account;    
  34.         int     amount;    
  35.     
  36.         public AddThread(Account account, int amount) {    
  37.             this.account = account;    
  38.             this.amount = amount;    
  39.         }    
  40.     
  41.         public void run() {    
  42.             for (int i = 0; i < 200000; i++) {    
  43.                 account.add(amount);    
  44.             }    
  45.         }    
  46.     }    
  47.     
  48.     static class WithdrawThread implements Runnable {    
  49.         Account account;    
  50.         int     amount;    
  51.     
  52.         public WithdrawThread(Account account, int amount) {    
  53.             this.account = account;    
  54.             this.amount = amount;    
  55.         }    
  56.     
  57.         public void run() {    
  58.             for (int i = 0; i < 100000; i++) {    
  59.                 account.withdraw(amount);    
  60.             }    
  61.         }    
  62.     }    
  63. }    

第一次执行结果为10200，第二次执行结果为1060，每次执行的结果都是不确定的，因为线程的执行顺序

是不可预见的。这是java同步产生的根源，synchronized关键字保证了多个线程对于同步块是互斥的，

synchronized作为一种同步手段，解决java多线程的执行有序性和内存可见性，而volatile关键字之解决

多线程的内存可见性问题。后面将会详细介绍。

synchronized关键字 

 上面说了，java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量，

这一段代码成为互斥区或临界区，为了保证共享变量的正确性，synchronized标示了临界区。典型的用法如下：

[java] view plain copy
  1. synchronized(锁){    
  2.      临界区代码    
  3. }   

为了保证银行账户的安全，可以操作账户的方法如下：

[java] view plain copy
  1. public synchronized void add(int num) {    
  2.      balance = balance + num;    
  3. }    
  4. public synchronized void withdraw(int num) {    
  5.      balance = balance - num;    
  6. }    

刚才不是说了synchronized的用法是这样的吗：

[java] view plain copy
  1. synchronized(锁){    
  2. 临界区代码    
  3. }    

那么对于public synchronized void add(int num)这种情况，意味着什么呢？其实这种情况，锁就是这个方法所在的对象。

同理，如果方法是public  static synchronized void add(intnum)，那么锁就是这个方法所在的class。


        理论上，每个对象都可以做为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，

一个没有共享的对象作为锁是没有意义的。假如有这样的代码：

[java] view plain copy
  1. public class ThreadTest{    
  2.   public void test(){    
  3.      Object lock=new Object();    
  4.      synchronized (lock){    
  5.         //do something    
  6.      }    
  7.   }    
  8. }   

lock变量作为一个锁存在根本没有意义，因为它根本不是共享对象，每个线程进来都会执行Object lock=new Object();

每个线程都有自己的lock，根本不存在锁竞争。

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了

被阻塞的线程，当一个被线程被唤醒(notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行

account.add方法时，jvm会检查锁对象account的就绪队列是否已经有线程在等待，如果有则表明account的锁已经

被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，执行account.add方法。如果恰好在

这个时候，线程b要执行account.withdraw方法，因为线程a已经获得了锁还没有释放，所以线程b要进入account的

就绪队列，等到得到锁后才可以执行。一个线程执行临界区代码过程如下：

1获得同步锁

2清空工作内存

3从主存拷贝变量副本到工作内存

4对这些变量计算

5将变量从工作内存写回到主存

6释放锁

可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

生产者/消费者模式

生产者/消费者模式其实是一种很经典的线程同步模型，很多时候，并不是光保证多个线程对某共享资源操作的互斥性就够了，

往往多个线程之间都是有协作的假设有这样一种情况，有一个桌子，桌子上面有一个盘子，盘子里只能放一颗鸡蛋，

A专门往盘子里放鸡蛋，如果盘子里有鸡蛋，则一直等到盘子里没鸡蛋，B专门从盘子里拿鸡蛋，如果盘子里没鸡蛋，

则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区，每次往盘子放鸡蛋应该都是互斥的，A的等待其实就是

主动放弃锁，B等待时还要提醒A放鸡蛋。如何让线程主动释放锁很简单，调用锁的wait()方法就好。

wait方法是从Object来的，所以任意对象都有这个方法。看这个代码片段：

[java] view plain copy
  1. Object lock=new Object();//声明了一个对象作为锁    
  2.    synchronized (lock) {    
  3.        balance = balance - num;    
  4.        //这里放弃了同步锁，好不容易得到，又放弃了    
  5.        lock.wait();    
  6. }    

    如果一个线程获得了锁lock，进入了同步块，执行lock.wait()，那么这个线程会进入到lock的阻塞队列。如果调用

lock.notify()则会通知阻塞队列的某个线程进入就绪队列。

声明一个盘子，只能放一个鸡蛋

[java] view plain copy
  1. import java.util.ArrayList;    
  2. import java.util.List;    
  3.     
  4. public class Plate {    
  5.     
  6.     List<Object> eggs = new ArrayList<Object>();    
  7.     
  8.     public synchronized Object getEgg() {    
  9.         if (eggs.size() == 0) {    
  10.             try {    
  11.                 wait();    
  12.             } catch (InterruptedException e) {    
  13.             }    
  14.         }    
  15.     
  16.         Object egg = eggs.get(0);    
  17.         eggs.clear();// 清空盘子    
  18.         notify();// 唤醒阻塞队列的某线程到就绪队列    
  19.         System.out.println("拿到鸡蛋");    
  20.         return egg;    
  21.     }    
  22.     
  23.     public synchronized void putEgg(Object egg) {    
  24.         if (eggs.size() > 0) {    
  25.             try {    
  26.                 wait();    
  27.             } catch (InterruptedException e) {    
  28.             }    
  29.         }    
  30.         eggs.add(egg);// 往盘子里放鸡蛋    
  31.         notify();// 唤醒阻塞队列的某线程到就绪队列    
  32.         System.out.println("放入鸡蛋");    
  33.     }    
  34.         
  35.     static class AddThread extends Thread{    
  36.         private Plate plate;    
  37.         private Object egg=new Object();    
  38.         public AddThread(Plate plate){    
  39.             this.plate=plate;    
  40.         }    
  41.             
  42.         public void run(){    
  43.             for(int i=0;i<5;i++){    
  44.                 plate.putEgg(egg);    
  45.             }    
  46.         }    
  47.     }    
  48.         
  49.     static class GetThread extends Thread{    
  50.         private Plate plate;    
  51.         public GetThread(Plate plate){    
  52.             this.plate=plate;    
  53.         }    
  54.             
  55.         public void run(){    
  56.             for(int i=0;i<5;i++){    
  57.                 plate.getEgg();    
  58.             }    
  59.         }    
  60.     }    
  61.         
  62.     public static void main(String args[]){    
  63.         try {    
  64.             Plate plate=new Plate();    
  65.             Thread add=new Thread(new AddThread(plate));    
  66.             Thread get=new Thread(new GetThread(plate));    
  67.             add.start();    
  68.             get.start();    
  69.             add.join();    
  70.             get.join();    
  71.         } catch (InterruptedException e) {    
  72.             e.printStackTrace();    
  73.         }    
  74.         System.out.println("测试结束");    
  75.     }    
  76. }   

执行结果：

synchronized关键字 

 上面说了，java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量，

这一段代码成为互斥区或临界区，为了保证共享变量的正确性，synchronized标示了临界区。典型的用法如下：

[java] view plain copy
  1. synchronized(锁){    
  2.      临界区代码    
  3. }   

为了保证银行账户的安全，可以操作账户的方法如下：

[java] view plain copy
  1. public synchronized void add(int num) {    
  2.      balance = balance + num;    
  3. }    
  4. public synchronized void withdraw(int num) {    
  5.      balance = balance - num;    
  6. }    

刚才不是说了synchronized的用法是这样的吗：

[java] view plain copy
  1. synchronized(锁){    
  2. 临界区代码    
  3. }    

那么对于public synchronized void add(int num)这种情况，意味着什么呢？其实这种情况，锁就是这个方法所在的对象。

同理，如果方法是public  static synchronized void add(intnum)，那么锁就是这个方法所在的class。


        理论上，每个对象都可以做为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，

一个没有共享的对象作为锁是没有意义的。假如有这样的代码：

[java] view plain copy
  1. public class ThreadTest{    
  2.   public void test(){    
  3.      Object lock=new Object();    
  4.      synchronized (lock){    
  5.         //do something    
  6.      }    
  7.   }    
  8. }   

lock变量作为一个锁存在根本没有意义，因为它根本不是共享对象，每个线程进来都会执行Object lock=new Object();

每个线程都有自己的lock，根本不存在锁竞争。

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了

被阻塞的线程，当一个被线程被唤醒(notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行

account.add方法时，jvm会检查锁对象account的就绪队列是否已经有线程在等待，如果有则表明account的锁已经

被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，执行account.add方法。如果恰好在

这个时候，线程b要执行account.withdraw方法，因为线程a已经获得了锁还没有释放，所以线程b要进入account的

就绪队列，等到得到锁后才可以执行。一个线程执行临界区代码过程如下：

1获得同步锁

2清空工作内存

3从主存拷贝变量副本到工作内存

4对这些变量计算

5将变量从工作内存写回到主存

6释放锁

可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

生产者/消费者模式

生产者/消费者模式其实是一种很经典的线程同步模型，很多时候，并不是光保证多个线程对某共享资源操作的互斥性就够了，

往往多个线程之间都是有协作的假设有这样一种情况，有一个桌子，桌子上面有一个盘子，盘子里只能放一颗鸡蛋，

A专门往盘子里放鸡蛋，如果盘子里有鸡蛋，则一直等到盘子里没鸡蛋，B专门从盘子里拿鸡蛋，如果盘子里没鸡蛋，

则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区，每次往盘子放鸡蛋应该都是互斥的，A的等待其实就是

主动放弃锁，B等待时还要提醒A放鸡蛋。如何让线程主动释放锁很简单，调用锁的wait()方法就好。

wait方法是从Object来的，所以任意对象都有这个方法。看这个代码片段：

[java] view plain copy
  1. Object lock=new Object();//声明了一个对象作为锁    
  2.    synchronized (lock) {    
  3.        balance = balance - num;    
  4.        //这里放弃了同步锁，好不容易得到，又放弃了    
  5.        lock.wait();    
  6. }    

    如果一个线程获得了锁lock，进入了同步块，执行lock.wait()，那么这个线程会进入到lock的阻塞队列。如果调用

lock.notify()则会通知阻塞队列的某个线程进入就绪队列。

声明一个盘子，只能放一个鸡蛋

[java] view plain copy
  1. import java.util.ArrayList;    
  2. import java.util.List;    
  3.     
  4. public class Plate {    
  5.     
  6.     List<Object> eggs = new ArrayList<Object>();    
  7.     
  8.     public synchronized Object getEgg() {    
  9.         if (eggs.size() == 0) {    
  10.             try {    
  11.                 wait();    
  12.             } catch (InterruptedException e) {    
  13.             }    
  14.         }    
  15.     
  16.         Object egg = eggs.get(0);    
  17.         eggs.clear();// 清空盘子    
  18.         notify();// 唤醒阻塞队列的某线程到就绪队列    
  19.         System.out.println("拿到鸡蛋");    
  20.         return egg;    
  21.     }    
  22.     
  23.     public synchronized void putEgg(Object egg) {    
  24.         if (eggs.size() > 0) {    
  25.             try {    
  26.                 wait();    
  27.             } catch (InterruptedException e) {    
  28.             }    
  29.         }    
  30.         eggs.add(egg);// 往盘子里放鸡蛋    
  31.         notify();// 唤醒阻塞队列的某线程到就绪队列    
  32.         System.out.println("放入鸡蛋");    
  33.     }    
  34.         
  35.     static class AddThread extends Thread{    
  36.         private Plate plate;    
  37.         private Object egg=new Object();    
  38.         public AddThread(Plate plate){    
  39.             this.plate=plate;    
  40.         }    
  41.             
  42.         public void run(){    
  43.             for(int i=0;i<5;i++){    
  44.                 plate.putEgg(egg);    
  45.             }    
  46.         }    
  47.     }    
  48.         
  49.     static class GetThread extends Thread{    
  50.         private Plate plate;    
  51.         public GetThread(Plate plate){    
  52.             this.plate=plate;    
  53.         }    
  54.             
  55.         public void run(){    
  56.             for(int i=0;i<5;i++){    
  57.                 plate.getEgg();    
  58.             }    
  59.         }    
  60.     }    
  61.         
  62.     public static void main(String args[]){    
  63.         try {    
  64.             Plate plate=new Plate();    
  65.             Thread add=new Thread(new AddThread(plate));    
  66.             Thread get=new Thread(new GetThread(plate));    
  67.             add.start();    
  68.             get.start();    
  69.             add.join();    
  70.             get.join();    
  71.         } catch (InterruptedException e) {    
  72.             e.printStackTrace();    
  73.         }    
  74.         System.out.println("测试结束");    
  75.     }    
  76. }   

执行结果：

1. 放入鸡蛋  

2. 拿到鸡蛋  

3. 放入鸡蛋  

4. 拿到鸡蛋  

5. 放入鸡蛋  

6. 拿到鸡蛋  

7. 放入鸡蛋  

8. 拿到鸡蛋  

9. 放入鸡蛋  

10.拿到鸡蛋  

测试结束 

声明一个Plate对象为plate，被线程A和线程B共享，A专门放鸡蛋，B专门拿鸡蛋。假设

1开始，A调用plate.putEgg方法，此时eggs.size()为0，因此顺利将鸡蛋放到盘子，还执行了notify()方法，

唤醒锁的阻塞队列的线程，此时阻塞队列还没有线程。

2又有一个A线程对象调用plate.putEgg方法，此时eggs.size()不为0，调用wait()方法，自己进入了锁对象的阻塞队列。

3此时，来了一个B线程对象，调用plate.getEgg方法，eggs.size()不为0，顺利的拿到了一个鸡蛋，

还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列有一个A线程对象，唤醒后，

它进入到就绪队列，就绪队列也就它一个，因此马上得到锁，开始往盘子里放鸡蛋，此时盘子是空的，

因此放鸡蛋成功。

4假设接着来了线程A，就重复2；假设来料线程B，就重复3。

整个过程都保证了放鸡蛋，拿鸡蛋，放鸡蛋，拿鸡蛋。

volatile关键字

volatile是java提供的一种同步手段，只不过它是轻量级的同步，为什么这么说，因为volatile只能保证多线程的内存可见性，

不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性，例如synchronized。任何被volatile修饰的变量，

都不拷贝副本到工作内存，任何修改都及时写在主存。因此对于Valatile修饰的变量的修改，所有线程马上就能看到，

但是volatile不能保证对变量的修改是有序的。什么意思呢？假如有这样的代码：

[java] view plain copy
  1. public class VolatileTest{    
  2.   public volatile int a;    
  3.   public void add(int count){    
  4.        a=a+count;    
  5.   }    
  6. }    

当一个VolatileTest对象被多个线程共享，a的值不一定是正确的，因为a=a+count包含了好几步操作，而此时多个线程

的执行是无序的，因为没有任何机制来保证多个线程的执行有序性和原子性。volatile存在的意义是，任何线程对a的修改，

都会马上被其他线程读取到，因为直接操作主存，没有线程对工作内存和主存的同步。所以，volatile的使用场景是

有限的，在有限的一些情形下可以使用 volatile变量替代锁。要使 volatile变量提供理想的线程安全

必须同时满足下面两个条件:

1)对变量的写操作不依赖于当前值。

2)该变量没有包含在具有其他变量的不变式中 

volatile只保证了可见性，所以Volatile适合直接赋值的场景，如

[java] view plain copy
  1. public class VolatileTest{    
  2.   public volatile int a;    
  3.   public void setA(int a){    
  4.       this.a=a;    
  5.   }    
  6. }    

在没有volatile声明时，多线程环境下，a的最终值不一定是正确的，因为this.a=a;涉及到给a赋值和将a同步回主存的步骤，

这个顺序可能被打乱。如果用

volatile声明了，读取主存副本到工作内存和同步a到主存的步骤，相当于是一个原子操作。所以简单来说，volatile适合这种场景：

一个变量被多个线程共享，线程直接给这个变量赋值。这是一种很简单的同步场景，

这时候使用volatile的开销将会非常小。




0 0
下载行者软件 下载行者软件
原创粉丝点击
热门IT博客
淘宝茶叶店铺淘宝茶叶店铺
软件销售好做吗软件销售好做吗
淘宝网民真实评价
数据交换平台etl
网络机柜
网络电视中天新闻直播
灰烬使者知乎
淘宝节日
中信出版社 知乎
网络文明传播志愿者
淘宝买婚纱靠谱吗
微缘网络是真的假的
javascript阴阳师脚本
node.js介绍
外国人看中国妹子知乎
淘宝小号无忧网
mysql 左联查询
尹欣新东方 知乎
python量化书籍
各种算法的时间复杂度
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 欧式内窗套 窗套多厚 石材包窗套 窗套报价 半包窗套 窗套和门套 室外窗套线 金属窗套 别墅石材窗套 做不做窗套 外窗套效果图 窗套施工工艺 不锈钢窗套安装 水泥窗套价格 eps线条窗套 保温窗套 实木窗套价格 包窗套效果 为什么要包窗套 窗套多宽 美心窗套价格 红色窗套效果图 实木门套窗套价格 瓷砖窗套效果图 家装包窗套 窗套线条图片 窗套不包 包窗套步骤 包门窗套价格 飘窗窗套怎么做 门套线窗套线 实木烤漆窗套价格 窗套实木 窗包套 复古窗套 飘窗窗套设计 窗套尺寸 外窗套模具 包窗户 包一个门套多少钱一米 包窗口

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里