Java基础-线程同步、线程锁

最新推荐文章于 2024-06-03 10:32:26 发布

洋葱ycy

最新推荐文章于 2024-06-03 10:32:26 发布

阅读量128

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/ycy0706/article/details/91040566

版权

java 专栏收录该内容

160 篇文章 2 订阅

订阅专栏

线程不同步，会导致数据不同步

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

public class Demo1 implements Runnable{

   /**
   * @param args
   */
   private int shushu=1;
   public void run() {
       // TODO Auto-generated method stub
       while(shushu<10){
           System.out.println(" 数数到："+shushu);
           shushu++;
       }
   }

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Demo1 d1 = new Demo1();
       new Thread(d1,"1号线程").start();
       new Thread(d1,"2号线程").start();
       new Thread(d1,"3号线程").start();
   }

}

1、线程同步

有且只能有一个线程进行，一个线程完成，另一个线程才能进入；

1）加上同步关键字synchronized，实现同步方法

    private int shushu=1;
   public synchronized void run() { //加上同步关键字 synchronized
       // TODO Auto-generated method stub
       while(shushu<10){
           System.out.println(" 数数到："+shushu);
           shushu++;
       }
   }

2）synchronized(this){}同步块

    private int shushu=1;
   public void run() {
       // TODO Auto-generated method stub
       synchronized(this){   //加上同步块
       while(shushu<10){
           System.out.println(" 数数到："+shushu);
           shushu++;
       }
       }
   }

2、线程锁

Java线程加锁机制：synchronized、Lock、Condition

1、synchronized

把代码块声明为 synchronized，有两个重要后果，通常是指该代码具有 原子性（atomicity）和 可见性（visibility）。

原子性：只能有一个线程进行访问。防止多线程共享导致的冲突。

可见性：一个线程对数据进行了改变，其他线程是科技的，保证共享变量的结果是线程执行之后的结果；主要原理是，当对象获取锁时，首先使得自己的高速缓存无效，然后直接从主内存中装入变量。同时在对象释放锁之前会刷新告诉缓存，强制使得更改出现在主内存中。这样可以保证同一个锁的线程看到的变量的同一个值。读取上一个线程写入的变量，更改下一个线程读取的变量。

限制：1）无法中断一个正在等待获得锁的线程；

2）无法通过投票的得到锁，如果不想等下去，也就没办法得到锁；

3）同步还要去锁的释放只能在与获得锁所在的堆栈相同的堆栈帧中进行，很多情况下，这没问题，而且与异常处理交互的很好，但是，存在一些非块结果的锁更适合的情况。

2、ReentrantLock

Java.util.concurrent.lock 中的Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。

ReentrantLock 类实现了Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。（换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。）

需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内，也就是一定要进行执行。

3、读写锁ReadWriteLock

读取线程和写入线程互不干扰是正常的，但是读取线程不应该互斥！

可以用读写锁ReadWriteLock实现：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

与互斥锁定相比，读-写锁定允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程）。读写锁允许并发可以提升性能。

4、线程间通信Condition

Condition可以替代传统的线程间通信，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()。

传统线程的通信方式，Condition都可以实现。

注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。

Condition的强大之处在于它可以为多个线程间建立不同的Condition

看JDK文档中的一个例子：假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存put 线程和take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个Condition 实例来做到这一点。

优点：
假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程。
那么假设只有一个Condition会有什么效果呢？缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。

readwriteLock 适合读多写少的并发场景；

copyOnwriteArrayList 读远远大于写，例如缓存

ReadWriteLock 写时其他线程无法读或者写，读时其他线程无法写，但可以读。读远远大于写。

ConcurrentHashMap 线程安全的HashTable，提供线程安全的方法，读取不加锁，写时锁的力度小，不用对整体进行加锁。