Java高并发学习(六)

蔚落 2022-05-09 17:20 274阅读 0赞

Java高并发学习(6)

线程安全的概念与synchronized

并行程序开发的一大关注点是线程安全问题。由于读写者问题产生的错误，会导致数据不一致。虽然在使用volatile关键字后这种错误情况有所改善。但是，volatile并不能真正的保证线程安全。他只能保证一个线程修改数据后其他线程能看到这个改动。但当两个线程同时修改一个数据时，依然会产生冲突。

下面代码演示了一个计数器，两个线程同时对i进行累加操作，个执行100000次。我们希望当两个线程执行结束后i的值为200000，但事实往往并非如此。如果你多次执行下面的代码，你会发现i的值总是小于200000。这就是两个线程同时对i写入，其中一个线程结果会覆盖另一个(虽然这时候i被声明为volatile变量)。

>   
> public class fist\{  
>     static int i =0;  
>     public static class MyThread\_Write extends Thread\{  
>         @Override  
>         public void run()\{  
>             for(int j=0;j<100000;j++)\{  
>                 i++;  
>             \}  
>         \}  
>     \}  
>       
>     public static void main(String args\[\]) throws InterruptedException \{  
>         MyThread\_Write t1 = new MyThread\_Write();  
>         MyThread\_Write t2 = new MyThread\_Write();  
>         t1.start();  
>         t2.start();  
> t1.join();  
> t2.join();  
>         System.out.println(i);  
>     \}  
> \}

3次输出结果如下：

![70][]![70 1][]![70 2][]

上述结果产生的原因:假设线程1和线程2同时读取i为0，并各自计算得到了i=1，并先后写入到这个结果，因此，虽然i++被执行了两次，但是实际i的值只增加了1。

要从根本上解决这个问题，我们就要保证多个线程在对i进行操作时完全同步，也就是说，当A线程在写入时，线程B不仅不能写入，同时也不能读。因为在线程A写完之前，线程读取的一定是一个过期数据。Java中提供了一个重要的关键字synchronized来实现这个功能。

关键字synchronized关键字的作用是实现线程间的同步。他的工作是对同步代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程将的安全性。

关键字synchronized可以有多重种用法。这里做一个简单的整理:

·指定加锁对象：对给定对象加锁，进入同步代码前要获得指定的锁。

·直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

·直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

下面代码，将synchronized作用于本类，因此，没当线程进入synchronized包裹的代码段，就都会要求请求fist.class的锁。如果其他线程持有这把锁，那么新到的线程就必须等待。这样，就保证了每一次只能有一个线程进行i++操作。

> public class fist\{  
>     static int i =0;  
>     public static class MyThread\_Write extends Thread\{  
>         @Override  
>         public void run()\{  
>             synchronized (fist.class) \{  
>                 for(int j=0;j<100000;j++)\{  
>                     i++;  
>                 \}  
>             \}  
>         \}  
>     \}  
>       
>     public static void main(String args\[\]) throws InterruptedException \{  
>         MyThread\_Write t1 = new MyThread\_Write();  
>         MyThread\_Write t2 = new MyThread\_Write();  
>         t1.start();  
>         t2.start();  
>         t1.join();  
>         t2.join();  
>         System.out.println(i);  
>     \}  
> \}

执行结果：

![70 3][]  
当然，也可以让关键字作用于一个实例方法。这就是对对象中的方法加锁，但这里先给出一种错误的加锁方式。

>   
> public class fist\{  
>     static int i =0;  
>     public static class MyThread\_Write extends Thread\{  
>         public synchronized void increase()\{  
>             i++;  
>         \}  
>         @Override  
>         public void run()\{  
>             for(int j=0;j<100000;j++)\{  
>                 increase();  
>             \}  
>         \}  
>     \}  
>       
>     public static void main(String args\[\]) throws InterruptedException \{  
>         MyThread\_Write t1 = new MyThread\_Write();  
>         MyThread\_Write t2 = new MyThread\_Write();  
>         t1.start();  
>         t2.start();  
>         t1.join();  
>         t2.join();  
>         System.out.println(i);  
>     \}  
> \}

上述代码就犯了个严重的错误。虽然声明了increase()方法是一个同步方法。但很不幸的是，这段代码指向的是不同的increase()方法，这是什么意思呢？其实我们在创建线程t1和t2时分别用了两次new MyThread\_Write()，然后java虚拟机在内存中创建了两个 MyThread\_Write对象，这两个对象都有increase()方法，也就是说，在内存中有两个increase()方法。然而我们只让每一个对象对自己的increase()方法上了锁。

那怎么解决这个问题呢？我们会想要是内存中只有一个increase()方法就好了，无论我们创造多少个 MyThread\_Write对象，他们的increase()方法都指向内存中唯一的increase()方法就好了！那这不就是静态方法吗！其实我们只要把increase()方法声明为静态方法就好了。

> public class fist\{  
>     static int i =0;  
>     public static class MyThread\_Write extends Thread\{  
>         public static synchronized void increase()\{  
>             i++;  
>         \}  
>         @Override  
>         public void run()\{  
>             for(int j=0;j<100000;j++)\{  
>                 increase();  
>             \}  
>         \}  
>     \}  
>       
>     public static void main(String args\[\]) throws InterruptedException \{  
>         MyThread\_Write t1 = new MyThread\_Write();  
>         MyThread\_Write t2 = new MyThread\_Write();  
>         t1.start();  
>         t2.start();  
>         t1.join();  
>         t2.join();  
>         System.out.println(i);  
>     \}  
> \}

除了用于线程同步，确保线程的安全之外，synchronized还可以确保线程间的可见性和有序性。从可见性的角度上讲，synchronized完全可以代替volatile的功能，只是使用上没有那么方便。就有序性而言，由于synchronized每一次只有一个线程可以访问同步块，因此，无论同步块内的代码如何被乱序执行，只要保证串行语义一致，那么执行的结果总是一样的。换而言之，被synchronized限制的多个线程是串行执行的。  
\---------------------

[70]: https://img-blog.csdn.net/20181017105200412?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N6Y251b251bw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: https://img-blog.csdn.net/20181017105230969?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N6Y251b251bw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 2]: /images/20220506/ca42669e25774042a841bb2c55dba704.png
[70 3]: /images/20220506/2bd896926b124950b0c4ac315bd76e3a.png