多线程：5-线程同步

阅读量

5.线程同步

线程同步（synchronized）

  • 多个线程操作同一个对象时，如果某些线程想修改此对象，需要线程同步。
    • 对比并发：同一个对象被多个线程同时操作称为并发。（如上万人同时抢100张票）
  • 线程同步其实是一种等待机制，多个同时访问此对象的线程，会进入这个对象的 等待池 形成队列。等待前一个线程使用完毕，下一个线程再使用。（即线程排队等待）
  • 线程同步 形成条件：队列 + 锁
    • 队列：排队的线程形成队列。
    • 锁：保证正在执行的线程的安全性（厕所排队，厕所里的人把门关上，门上的插销就是锁）
  • 由于同一进程的多个线程共享同一块存储空间，在带来便利的同时，也带来了访问冲突问题。为了保证数据在方法中被访问时的正确性，在访问时需要加入 锁机制synchronized。当一个线程获得对象的排他锁，会独占资源，其他线程必须等待其使用完后释放锁。存在以下问题：
    • 一个线程持有锁，会导致其他所有需要此锁的线程挂起，降低了性能。（性能和安全不能兼得）
    • 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换 和 调度延时，引起性能问题。
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁，导致了优先级倒置，引起性能问题。

1.三大不安全案例

线程不安全 例1： 不安全的买票

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
35
36
37
38
39
40
41
42
43
44
45
// 不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket, "aa").start();
        new Thread(buyTicket, "bb").start();
        new Thread(buyTicket, "cc").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums = 10;  // 票数量
    boolean flag = true;          // 停止线程标志

    // 买票
    private void buy(){
        if(ticketNums <= 0){
            flag = false;
            return;
        }
        
        // 买票的线程名
        String name = Thread.currentThread().getName();

        // 模拟延时 来 放大问题的发生性
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 买票后 票数减1
        System.out.println(name + "买了票" + ticketNums--);
    }

    @Override
    public void run() {
        // 买票
        while (flag){
            buy();
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9
10
aa买了票5
bb买了票4
cc买了票3
bb买了票2
aa买了票1
bb买了票3   // 重复买
cc买了票0
bb买了票-1  // 有负数

// 原因：每个线程都有自己的工作内存，会把资源拷贝一份放在自己的内存中

线程不安全 例2： 同一账户，两人同时取钱 

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// 同一账户，两人同时取钱
public class UnsafeBank {
    public static void main(String[] args) {
        // 账户
        Account account = new Account(100, "农业银行");

        // 用户1、用户2
        Drawing user1 = new Drawing(account, 50, "张三");
        Drawing user2 = new Drawing(account, 100, "李四");

        // 启动线程
        user1.start();
        user2.start();
    }
}

// 账户
class Account{
    int money;   // 余额
    String name; // 卡名

    public Account() {
    }

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

// 银行：模拟取款
class Drawing extends Thread{
    Account account;    // 账户
    int drawingMoney;   // 取了多少钱
    int nowMoney;       // 现在手里有多少钱

    public Drawing() {
    }

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    // 取钱操作
    @Override
    public void run() {
        // 判断有没有钱
        if((account.money - drawingMoney) < 0){
            System.out.println(Thread.currentThread().getName() + "取时，钱不够");
            return;
        }

        // 模拟延时 放大问题发生率
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 卡内余额 = 余额 - 你取的钱
        account.money = account.money - drawingMoney;

        // 你手里的钱 = 手里的钱 + 取出的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println(account.name + "余额为：" + account.money);

        // this.getName() 等价于 Thread.currentThread().getName()
        System.out.println(this.getName() + "手里的钱：" + nowMoney);
    }
}

结果： 

1
2
3
4
农业银行余额为：-50
张三手里的钱：50
农业银行余额为：-50
李四手里的钱：100

线程不安全 例3： 不安全的集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();

        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }

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

结果：

1
2
3
4
8989

结果总是小于 1000
原因：有可能两个线程同一瞬间 添加进了 同一位置。

2.同步：

由于我们可以通过peivate关键字来保证 数据对象 只能被方法访问，所以只需针对方法提出一套机制。这套机制就是synchronized关键字，它包括两种方法：synchronized方法 和 synchronized块。

  • 同步方法：public synchronized void method(int args){}
  • 同步块：synchronized(obj){}

同步方法：

  • synchronized方法控制对“对象”的访问，每个对象都有一把锁。每个synchronized方法都必须获得 调用该方法的对象的锁 才能执行。否则线程会阻塞。方法一旦执行，就独占该锁，直到该方法结束才能释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
    • 缺陷：若一个大的方法声明为synchronized 将会影响效率。
  • 需要修改内容的方法才需要锁，查询操作不需要锁。（锁太多，会浪费资源）

同步块： synchronized(obj){}

  • Obj称之为 同步监视器
    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器。
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器是this，即锁的是当前方法所在对象，或是class。
    • 锁的对象obj，要是一个变化的量。（被修改的量）
  • 同步监视器的执行过程：
    1. 第一个线程访问，锁定同步监视器，执行其中的代码。
    2. 第二个线程访问，发现同步监视器被锁定，无法访问。
    3. 第一个线程访问完毕，解锁同步监视器。
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定 访问。

修改不安全的代码：
1.修改买票代码： 在购票方法buy() 上加synchronized。 

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
35
36
37
38
39
40
41
42
43
44
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket, "aa").start();
        new Thread(buyTicket, "bb").start();
        new Thread(buyTicket, "cc").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums = 5;  // 票数量
    boolean flag = true;          // 停止线程标志

    // 买票 (synchronized：同步方法)
    private synchronized void buy(){
        if(ticketNums <= 0){
            flag = false;
            return;
        }

        // 买票的线程名
        String name = Thread.currentThread().getName();

        // 模拟延时 来 放大问题的发生性
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 买票后 票数减1
        System.out.println(name + "买了票" + ticketNums--);
    }

    @Override
    public void run() {
        // 买票
        while (flag){
            buy();
        }
    }
}

结果：

1
2
3
4
5
cc买了票5
cc买了票4
aa买了票3
aa买了票2
bb买了票1

2.银行取钱： 使用synchronized块

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// 同一账户，两人同时取钱
public class UnsafeBank {
    public static void main(String[] args) {
        // 账户
        Account account = new Account(100, "农业银行");

        // 用户1、用户2
        Drawing user1 = new Drawing(account, 50, "张三");
        Drawing user2 = new Drawing(account, 100, "李四");

        // 启动线程
        user1.start();
        user2.start();
    }
}

// 账户
class Account{
    int money;   // 余额
    String name; // 卡名

    public Account() {
    }

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

// 银行：模拟取款
class Drawing extends Thread{
    Account account;    // 账户
    int drawingMoney;   // 取了多少钱
    int nowMoney;       // 现在手里有多少钱

    public Drawing() {
    }

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    // 取钱操作
    @Override
    public void run() {
        synchronized (account){
            // 判断有没有钱
            if((account.money - drawingMoney) < 0){
                System.out.println(Thread.currentThread().getName() + "取时，钱不够");
                return;
            }

            // 模拟延时 放大问题发生率
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 卡内余额 = 余额 - 你取的钱
            account.money = account.money - drawingMoney;

            // 你手里的钱 = 手里的钱 + 取出的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name + "余额为：" + account.money);

            // this.getName() 等价于 Thread.currentThread().getName()
            System.out.println(this.getName() + "手里的钱：" + nowMoney);
        }
    }
}

3.集合： 使用synchronized块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {

        List<String> list2 = new ArrayList<>();

        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                // 锁住变化的元素
                synchronized (list2){
                    list2.add(Thread.currentThread().getName());
                }
            }).start();
        }
        
        // 延时一段时间，再结束主线程（确保子线程跑完）
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println(list2.size());
    }
}

4.JUC安全类型集合： CopyOnWriteArrayList

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }

        // 延时一段时间，再结束主线程（确保子线程跑完）
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

失败是成功之母

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

JAVA<br><br>学习永不止步<br>简简单单