ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

【学习笔记】线程（六）之线程同步

2022-08-02 12:01:40  阅读：135  来源： 互联网

标签：同步 synchronized Thread void 笔记 线程 new public


线程（六）之线程同步

 

线程同步

  • 并发：同一个对象被多个线程同时操作

    • 上万人同时抢100张票

    • 两个银行同时取钱

  • 在现实生活中，我们遇到“同一个对象被多个线程同时操作”这种问题，比如食堂打饭，解决办法就是排队

  • 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程在使用。

 

  • 队列和锁：在线程访问对象时，加入锁机制 synchronized, 当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题

    • 一个线程持有锁会导致其他所有需要此锁的线程挂起

    • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换，和调度延时，引起性能问题

    • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级导致，引起性能问题

 

三大不安全案例

 

买票案例

package com.thread.syn;
​
public class UnsafeTicket {
​
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
​
        new Thread(buyTicket,"张三").start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"王五").start();
​
    }
}
​
class BuyTicket implements Runnable{
​
    //票数
    private int ticketNum = 10;
    boolean flag = true;  //外部停止方式
    @Override
    public void run() {
        while(flag){
           buy();
        }
    }
    public void buy(){
        if (ticketNum < 0){
            flag = false;
            return;
        }
        //延时：防止一个人抢到所有票
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");
    }
}

image-20220802093419840

 

线程不安全，票数出现负数

 

每个线程都在自己的工作内存交互，内存控制不当会造成数据不一致

买票时，每个线程都把票数拿到自己的内存，当票数只剩一张时，所以它们看到的都是1，然后都去拿这一张票，当第一个线程拿到这张票时，票数修改为0，第二个线程再去拿时，票数就变成了-1.

 

银行取钱案例

package com.thread.syn;
​
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100);
        Bank you = new Bank(account,50,"你");
        Bank other  =new Bank(account,100,"其他人");
        you.start();
        other.start();
    }
}
​
//账户
class Account {
     int balance;    //余额
​
    public Account(int balance){
        this.balance = balance;
    }
}
​
//银行
class Bank extends Thread{
    Account account;
    int wantTake;    //想要取得钱
    int remain;     //手里的钱
    String name;    //谁取
​
    public Bank(Account account,int wantTake,String name){
        super(name);
        this.account = account;
        this.wantTake = wantTake;
    }
​
    @Override
    public void run() {
        if (account.balance - wantTake <0){
            System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
        }
​
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
​
        account.balance = account.balance - wantTake;
            remain  = remain + wantTake;
            System.out.println(Thread.currentThread().getName() + "取了" + wantTake);
            System.out.println(Thread.currentThread().getName() + "手里有" + remain);
            System.out.println("卡里余额：" + account.balance);
​
​
    }
​
    //取钱
    public void withDraw(){
​
    }
}

image-20220802101026097

 

 

线程不安全的集合

以ArrayList 为例

package com.thread.syn;
​
import java.util.ArrayList;
import java.util.List;
​
public class UnsafeList{
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
​
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println("集合中元素的数量："+list.size());
    }
​
}

image-20220802101636272

 

我们加入了10000个元素，实际加入集合的只有7761个，原因是当这些线程在同一瞬间把集合元素添加到集合的同一位置，就覆盖掉了前面的元素，所以集合中的元素数量才会少

 

如何解决不安全的问题？

同步方法

  • 我们要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：

synchronized 方法 和 synchronized 块

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

  • synchronized 方法控制对“对象”的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程获得这个锁，继续执行

  • 缺陷：若将一个大的方法申明为 synchronized 将会影响效率

    方法中需要修改的内容才需要锁，锁的太多，浪费资源

     

修改买票案例

在买票的方法前加上 synchronized

public synchronized void buy(){
    if (ticketNum < 0){
        flag = false;
        return;
    }
    //延时：防止一个人抢到所有票
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");
}

image-20220802111723945

 

 

修改银行取钱案例

按照上面的思路，我们应该去锁取钱的方法，即 run()方法

@Override
public synchronized void run() {
    if (account.balance - wantTake <0){
        System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
    }
​
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
​
    account.balance = account.balance - wantTake;
        remain  = remain + wantTake;
        System.out.println(Thread.currentThread().getName() + "取了" + wantTake);
        System.out.println(Thread.currentThread().getName() + "手里有" + remain);
        System.out.println("卡里余额：" + account.balance);
        
}

image-20220802112250614

但是结果依然是不安全的，原因就是我们锁run()方法，它默认锁的是this 即银行Bank，但是我们操作的对象是账户 Account，所以我们应该锁 账户 Account

但是我们没有办法用同步方法直接锁Account ，所以我们可以用同步块去锁

@Override
public  void run() {
    synchronized(account){
        if (account.balance - wantTake <0){
            System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
            return;
        }
​
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
​
        account.balance = account.balance - wantTake;
        remain  = remain + wantTake;
        System.out.println(Thread.currentThread().getName() + "取了" + wantTake);
        System.out.println(Thread.currentThread().getName() + "手里有" + remain);
        System.out.println("卡里余额：" + account.balance);
    }
​
}

image-20220802113043181

  • 锁的对象就是需要变化的量，需要增删改

 

修改线程不安全的集合

我们可以锁 list 集合

package com.thread.syn;
​
import java.util.ArrayList;
import java.util.List;
​
public class UnsafeList{
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
​
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
​
            }).start();
        }
        Thread.sleep(3000);
        System.out.println("集合中元素的数量："+list.size());
    }
​
}

image-20220802113517810

 

 

JUC 安全类型的集合

JUC: java.util.concurrent ：并发包

在JUC下有一个线程安全的集合 ：CopyOnWriteArrayList

package com.thread.syn;
​
import java.util.concurrent.CopyOnWriteArrayList;
​
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println("集合中元素的数量：" + list.size());
    }
}

image-20220802114947157

 

标签：同步,synchronized,Thread,void,笔记,线程,new,public
来源： https://www.cnblogs.com/wztblogs/p/16543299.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有