Java多线程 - 线程安全和线程同步解决线程安全问题_java模拟线程安全

线程安全问题

线程安全问题指的是: 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

举例: 取钱模型演示

需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元。

如果小明和小红同时来取钱，而且2人都要取钱10万元，可能出现什么问题呢？

在取钱之前都需要判断余额是否足够, 例如两个线程同时执行, 两个线程都进行了余额判断, 发现余额充足;

此时小明线程取走10万, 账户余额为0; 小红线程由于此时已经判断过余额, 继续取钱的时候就不会继续判断余额, 直接将余额取出来; 那么两个人都取走了10万, 银行就亏了10万, 这就是多线程带来的安全问题

线程安全问题模拟, 我们将上面的例子用代码模拟出来多线程的安全隐患:

需求:

小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟2人同时去取钱10万。

分析:

1. 需要提供一个账户类，创建一个账户对象代表2个人的共享账户。
2. 需要定义一个线程类，线程类可以处理账户对象。
3. 创建2个线程对象，传入同一个账户对象。
4. 启动2个线程，去同一个账户对象中取钱10万。

实现步骤:

模拟一个账户类给小明线程和小红线程, 我们模拟关键信息即可

public class Account {
    private double money;

    public  Account() {}

    public Account(double money) {
        this.money = money;
    }

    /**
        取钱方法
     */
    public void drawMoney(double money) {
        // 获取取钱人的名字
        String name = Thread.currentThread().getName();
        if (this.money >= money) { // 判断余额是否充足
            System.out.println(name + "取走了" + money + "元");
            this.money -= money;
        } else {
            System.out.println("余额不足");
        }
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

定义一个线程类用来处理账户对象

public class DrawThread extends Thread {
    private Account acc;

    public DrawThread(Account acc, String name) {
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        acc.drawMoney(100000);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在主类中, 创建2个线程对象，传入同一个账户对象; 启动2个线程，去同一个账户对象中取钱10万

public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        // 创建账户对象
        Account acc = new Account(100000);

        // 创建两个子线程, 并启动线程
        new DrawThread(acc, "小明").start(); // 小明取走了100000.0元
        new DrawThread(acc, "小红").start(); // 小红取走了100000.0元

        // 主线程睡眠两秒后, 查看余额
        Thread.sleep(2000);
        System.out.println(acc.getMoney()); // -100000.0
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

线程同步

为了解决上面线程安全的问题。

取钱案例出现问题的原因？

多个线程同时执行，发现账户都是够钱的。

如何才能保证线程安全呢？

让多个线程实现先后依次排队访问共享资源，这样就解决了安全问题

线程同步的核心:

线程同步的核心是加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

加锁的方式有三种方式: 同步代码块, 同步方法和Lock锁, 下面我们来分别学习加锁的方法

方式一: 同步代码块

作用：将出现线程安全问题的核心代码给上锁。

原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

同步代码块上锁的格式:

synchronized(同步锁对象) {
  	// 操作共享资源的代码(核心代码)
}
1
2
3

例如我们给上面模拟的线程安全例子中的核心代码进行加锁操作:

进行加锁操作就解决了线程安全问题

public class Account {
    private double money;

    public  Account() {}

    public Account(double money) {
        this.money = money;
    }

    /**
        取钱方法
     */
    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();

        // 对核心代码进行加锁, 这里锁对象随便使用了一个字符串模拟(无实际代表意义)
        synchronized ("chen") {
            if (this.money >= money) {
                System.out.println(name + "取走了" + money + "元");
                this.money -= money;
            } else {
                System.out.println("余额不足");
            }
        }
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

锁对象注意:

理论上：锁对象只要对于当前同时执行的线程来说是唯一的一个对象即可。

但是实际上使用任意唯一的锁对象并不好, 会影响其他无关线程的执行, 例如上面例子中, 会将其他无关的账户也锁起来。

锁对象的规范要求:

规范上：建议使用共享资源作为锁对象。

• 对于实例方法中, 建议使用this作为锁对象。

// 加锁, 使用共享资源作为锁对象
synchronized (this) {
}
1
2
3

• 对于静态方法中, 建议使用字节码（类名.class）对象作为锁对象。

// 加锁, 使用共享资源作为锁对象
synchronized (类名.class) {
}
1
2
3

方式二: 同步方法

作用: 将出现线程安全问题的核心方法给上锁。

原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

同步方法的上锁格式:

修饰符 synchronized 返回值类型 方法名称(形参列表) {
	  // 操作共享资源的代码
}
1
2
3

同步方法上锁演示代码:

// 给核心方法上锁
public synchronized void drawMoney(double money) {
    String name = Thread.currentThread().getName();

    if (this.money >= money) {
        System.out.println(name + "取走了" + money + "元");
        this.money -= money;
    } else {
        System.out.println("余额不足");
    }
}
1
2
3
4
5
6
7
8
9
10
11

同步方法底层原理:

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！

如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

方式三: Lock锁

Lock锁

为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。

Lock实现提供比使用synchronized方法和语句可以获得更广泛灵活的锁定操作。

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

Lock的API:

Lock使用演示代码:

基本使用如下, 我们可以看出Lock使用是非常灵活的

public class Account {
    private double money;
    // 定义一个示例变量锁对象, 每创建一个类就会创建一个锁对象, 加final修饰, 表示不可替换
    private final Lock lock = new ReentrantLock();

    public  Account() {}
    public Account(double money) {
        this.money = money;
    }
    
    public synchronized void drawMoney(double money) {
        String name = Thread.currentThread().getName();

        // 调用锁对象上锁
        lock.lock();
        if (this.money >= money) {
            System.out.println(name + "取走了" + money + "元");
            this.money -= money;
        } else {
            System.out.println("余额不足");
        }
        // 调用锁对象解锁
        lock.unlock();
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

但是如果我们上锁和解锁之间的代码出现了异常, 永远都不会执行解锁操作, 所以更严谨的写法是将解锁的操作放到try…finally中, 保证会执行解锁的操作

public synchronized void drawMoney(double money) {
    String name = Thread.currentThread().getName();

    // 调用锁对象上锁
    try {
        lock.lock();
        if (this.money >= money) {
            System.out.println(name + "取走了" + money + "元");
            this.money -= money;
        } else {
            System.out.println("余额不足");
        }
    } finally {
        // 调用锁对象解锁
        lock.unlock();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17