Java多线程之线程同步方法：synchronized与Lock

一、什么是线程同步？

多个线程操作同一个资源,即并发问题： 同一个对象被多个线程同时操作

多个线程访问同一个对象，某些线程还想修改对象的值，这时候会出现线程不安全的问题
线程同步是一种等待机制，即多个需要同时访问此对象的线程进入对象的等待池 形成队列，等待前面线程使用完毕，下一个线程再使用
形成条件：队列 + 锁
同一进程的多个线程共享同一块存储空间，方便之余也带来了访问冲突问题

因此，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制 synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁。
- 存在问题：
  1. 一个线程持有锁会导致其他所有需要此锁的线程挂起
  2. 多线程竞争下，加锁、释放锁会导致较多的上下文切换 和调度延时，引起性能问题
  3. 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

二、同步方法

synchronized 关键字

由于我们可以通过private关键字保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，即 synchronized关键字，包括两种用法：
- 1. synchronized方法
  2. synchronized块
```
public synchronized void method(int args){
    // 同步方法
}
```
synchronized 方法控制对 “对象”的访问，每个对象对应一把锁，每个synchronized 方法都必须获取调用该方法的锁才能执行，否则线程会阻塞；方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
synchronized 锁的是线程的共享资源 / 临界资源
缺陷：
- 如果将一个大的方法声明为synchronized 将会影响效率
- 方法里面需要修改的内容才需要锁，锁的太多反而浪费资源

同步块

同步块：synchronized(Obj)
Obj称之为 同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，默认同步监视器为this，也就是对象本身，或者是class
同步监视器的执行过程
1. 第一个线程访问：锁定同步监视器，执行其中代码
2. 第二个线程访问，发现同步监视器被锁定，无法访问
3. 第一个线程访问完毕，解锁同步监视器
4. 第二个线程访问，发现同步监视器没有锁，则锁定并访问
5. .....

补充知识：

JUC: java.util.concurrent 即并发编程

CopyOnWriteArrayList: util.concurrent包下的安全类型集合可保证线程安全，实现线程同步的功能！

 public static void main(String[] args) {

        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); // <> 里面包含的是 泛型

        for (int i = 0; i < 10000; i++) {
            new Thread(()->{

                list.add(Thread.currentThread().getName());

            }).start();
        }


        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());
    }

死锁

多个线程各自占有一些资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源并停止执行；
某一个同步块同时“拥有两个以上对象的锁”时，就可能发生“死锁”

死锁避免方法

产生死锁的四个必要条件：
- 1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求保持条件：一个进程因请求资源而阻塞时，对已经获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
只要想办法打破其中任意一个或多个条件，即可避免死锁发生

Lock(锁)

从JDK5.0开始，Java提供了更强大的线程同步机制——显式定义同步锁来实现同步

同步锁使用Lock对象来充当
java.util.concurrent.locks Lock接口是控制多个线程对共享资源进行访问的工具，锁提供了对共享资源的独占访问，每次只有一个线程对Lock对象加锁。线程开始访问共享资源之前应先获得Lock对象
ReentrantLock 类实现了Lock(可重入锁)，拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用ReentrantLock,可以显式加锁、释放锁

synchronized 与 Lock 的对比

Lock是显式锁（需手动开启和关闭锁） synchronized 是隐式锁，出了作用域自动释放
Lock只有代码块锁 synchronized 有代码块锁 + 方法锁
使用Lock锁，JVM将花费较少时间来调度线程 = > 性能更好 + 可拓展性强（提供更多子类）
优先使用顺序：
- Lock > 同步代码块（在方法体中，分配了相应资源）> 同步方法（在线程[run()]方法体之外）

class A{
    private final ReentrantLock lock = new ReentrantLock();
    
    @Override
    public void run() {
        while (true) {
            // 将延时放在加锁之前
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            try {
                lock.lock();// 加锁
                
                // 需要保证线程安全的代码块
                if (ticketNum > 0) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 拿到了 "+ ticketNum--);

                }else{
                    break;
                }

            } finally {
                lock.unlock(); // 解锁
            }
        }
    }
}

线程协作 重点！

生产者（Producer）- 消费者(Consumer)问题
- 线程同步问题生产者消费者共享同一个资源
- 生产者和消费者之间相互依赖，互为条件
- 在生产者-消费者问题中，仅有synchronized是不够的
  - synchronized可阻止并发更新同一个共享资源，实现同步
  - synchronized不能用来实现不同线程之间的消息传递（通信）
读(Read)写(Write)问题
理发师理发问题

三、线程通信

Java提供了几个方法用于线程通信
1. wait() — 线程一直等待，知道其他线程同志，与sleep不同，wait()会释放锁
2. wait() — 指定等待的毫秒数
3. notify() — 唤醒一个处于等待状态的线程
4. notifyAll() — 唤醒同一个对象上所有调用了wait() 方法的线程，优先级别高的线程优先调度
注意：以上方法均为Object类的方法，都只能在同步方法中或者同步代码块中使用，否则会抛出异常IllegalMonitorStateException

posted @ 2021-07-15 16:15 夕立君阅读(290) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Java多线程之线程同步方法：synchronized与Lock

一、什么是线程同步？

二、同步方法

synchronized 与 Lock 的对比

三、线程通信

公告