Java多线程之线程同步

Z时代
2024-01-10
分类：综合

java

多线程共享数据（多个线程共同访问相同的数据），需要进行数据同步，保证同一数据、同一时刻只能被一个线程访问。

使用同步是为了防止多个线程同一时刻对同一数据进行读写，如果对同一数据数据都只进行读操作、不进行修改，则不必使用同步。

以售票为例不使用同步

public class SaleTicketThread extends Thread {
    private static int ticket = 100; //票数，static
    @Override
    public void run() {
        while (ticket > 0) {
            System.out.println("售出第" + (100 - ticket + 1) + "个座位");
            ticket--;
        }
    }
}

public class SaleTicket {
    public static void main(String[] args) {
        SaleTicketThread thread1 = new SaleTicketThread();
        thread1.start();
        SaleTicketThread thread2 = new SaleTicketThread();
        thread2.start();
        SaleTicketThread thread3 = new SaleTicketThread();
        thread3.start();
    }
}

启动三个线程来售票，这3个线程都要访问同一个数据 SaleTicketThread.ticket 剩余票数

很容易出问题

三种常见的同步方式

同步方法默认用当前对象（this）或者当前类的class对象作为锁，会给整个方法都加锁

同步代码块可以选择以什么作为锁，可以只同步会发生同步问题的部分代码而不是整个方法，比同步方法更加细粒度

ReentrantLock 以ReentrantLock对象作为锁，可以只给部分代码加锁，比同步方法更加细粒度

1、同步方法

public class SaleTicketThread extends Thread {
    private static int ticket = 100; //票数，static
    protected static synchronized void saleTicket(){ //用synchronized修饰方法
        while (ticket > 0) { 
            System.out.println("售出第" + (100 - ticket + 1) + "个座位");
            ticket--;
        }
    }
    @Override
    public void run() {
        saleTicket();
    }
}

如果方法没有使用static修饰，是实例方法，默认以this（当前对象）作为锁，如果此线程类有多个实例（多条线程），这些线程使用的锁不是同一个对象，起不到同步的作用。

如果方法是静态方法，默认以当前类的class对象作为锁，如果此线程类有多个实例（多条线程），这些线程使用的锁是同一个对象，实现了同步，显然应该使用static。

同步方法有一个很大的问题：只作用于当前线程类，比如查询、售票2个线程类都要使用剩余票数这个共享数据，都使用同步方法，锁对象不同，这2个线程类之间并没有同步。

所以同步方法一般用于此共享数据只作用于一个线程类的多个实例。

锁的范围是固定（整个方法），不能修改，不灵活；使用情况还有限制，有点鸡肋。

相比之下，同步代码块、ReentrantLock的使用不受限制，强大多了。

2、同步代码块

public class SaleTicketThread extends Thread {
    private static Integer ticket = 100; //票数，static
    @Override
    public void run() {
        synchronized (ticket){ //锁要是Object类型
            while (ticket > 0) {
                System.out.println("售出第" + (100 - ticket + 1) + "个座位");
                ticket--;
            }
        }
    }
}

同步代码块可以自己决定要使用的锁对象，可以直接把共享数据作为锁，也可以新建一个Object对象作为锁。

要注意2点：

1、锁要是Object类型，int、float、char等基本类型没有继承Object，不能作为锁，要使用对应的包装类型。String继承了Object，可以作为锁。

2、访问这一共享数据的线程，使用的锁对象要相同（对象地址要相同）。

3、ReentrantLock

public class SaleTicketThread extends Thread {
    private static Integer ticket = 100; //票数，static
    private final static ReentrantLock lock=new ReentrantLock(); //锁对象，final static修饰，
    @Override
    public void run() {
        lock.lock(); //加锁
        while (ticket > 0) {
            System.out.println("售出第" + (100 - ticket + 1) + "个座位");
            ticket--;
        }
        lock.unlock(); //释放锁
    }
}

以ReentrantLock对象作为锁，注意所有要使用此共享数据的线程使用的应该是同一个ReentrantLock对象（要是同一个锁对象）。

其实和同步代码块差不多，lock()标志同步代码块开始，unlock()标志同步代码块结束。

可能发生异常的情况：

public class XxxThread extends Thread {
    private final static ReentrantLock lock=new ReentrantLock(); //锁对象，final static修饰
    @Override
    public void run() {
        //...
        lock.lock(); //加锁
        try{
            //......  //放在try中
        }catch ( ){
            //.....
        }finally {
            lock.unlock(); //在finally中释放锁，防止发生异常后锁没有释放，其它线程一直等待
        }
        //.....
    }
}