JAVA-多线程 四 {线程同步}JAVA从基础开始 -- 3

原创 于 2022-01-09 11:34:02 发布 · 312 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #后端

JAVA-多线程 四 {线程同步}JAVA从基础开始 -- 3

因为觉得这个线程同步挺重要的 ，所以放另一个文章开头。

线程同步

重点加难点，（不知道是不是真的难）

同步

◆并发：同一对象被多线程同时操作
（上万人同时抢有限额的火车票）
（两个银行同时去钱）
就是并发同步

◆现实生活中,我们会遇到”同一个资源,多个人都想使用”的问题,比如,食堂排队打饭,每个人都想吃饭,最天然的解決办法就是,排队.一个个来.
◆处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象这时候我们就需要线程同步.线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用

队列和锁

光有队列还不够，需要锁来锁住线程运行，当解锁后，接着下个线程运行--------安全性

◆由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保近数据在方法中被访问时的正确性,在访问时加入 锁机制 synchronized ,当个线程获得对象的排它锁,独占资源,其他线程必须等待使用后释放锁即可.荐往以下问题

◆一个线程持有锁会导致其他所有需要此锁的线程挂起
◆在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
◆如果一个优先级高的线程等待-个优先级低的线程释放锁会导致优先级倒置,引起性能问题

回顾不安全线程

//不安全的
package syn;
public class UnsafeBuyTicket implements Runnable {
    //票数
    private int ticketNums = 10;
    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
        }
    }

    public static void main(String[] args) {
        UnsafeBuyTicket testHread = new UnsafeBuyTicket();

        new Thread(testHread, "小明").start();
        new Thread(testHread, "黄牛").start();
        new Thread(testHread, "老师").start();
    }
}

会出现一张票被两个人拿到的问题：
在这里插入图片描述
//再来两个不安全的 …
1.银行取钱不安全案例

	package syn;

//不安全的取钱
//两个人去银行取钱
public class UnsafeBank1 {
    public static void main(String[] args) {
        //账户
        Account account = new Account(50, "结婚基金");
        Drawing you = new Drawing(account, 30, "张三");
        Drawing you1 = new Drawing(account, 30, "李四");
        you.start();
        you1.start();
    }
}

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

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

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

    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() +
                    "银行有：" + account.money +
                    "需要取" + drawingMoney +
                    "钱不足，取不了,手上有" + nowMoney);
            return;
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额
        account.money = account.money - drawingMoney;//取钱
        //手里的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(this.getName() +
                "银行有：" + account.money +
                "取钱:" + drawingMoney +
                "成功，手上有：" + nowMoney);
    }
}

2.List不安全

package syn;

import java.util.ArrayList;
import java.util.List;

//线程不安全合集
public class UnsafelList {
    public static void main(String[] args) throws InterruptedException {
        List<String >  list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

同步

同步方法

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

同步方法: public synchronized void method( int args)

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

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

同步方法：
== 弊端：方法里面需要修改的内容才上锁，锁太多，浪费资源 ==
使用：在方法上 加入synchronized

package syn;
public class UnsafeBuyTicket implements Runnable {
    //票数
    private int ticketNums = 10;
    //抛出
    private boolean flag = true;

    //synchronized同步方法 锁的是this
    @Override
    public void run() {
        while (true) {
            if (!flag) {
                break;
            } else {
                buy();
            }
        }
    }
    public synchronized void buy() {
        //模拟延时
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
        if (ticketNums <= 1) {
            flag = false;
        }
    }
    public static void main(String[] args) {
        UnsafeBuyTicket testHread = new UnsafeBuyTicket();
        new Thread(testHread, "小明").start();
        new Thread(testHread, "黄牛").start();
        new Thread(testHread, "老师").start();
    }
}

在这里插入图片描述
可以看到 它是一个一个运行的抢票任务，并且同一张票不会有多个人抢的情况出现

同步块

◆同步块: synchronized (Obj) { }
Obj称之为同步监视器

◆Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
◆同步方法中无需指定同步监视器,因为同步方法的同步监视器就是ts,就是这个对象本身,或者是 class

◆同步监视器的执行过程
1.第一个线程访问,锁定同步监视器,执行其中代码
2.第二个线程访问,发现司步监视器被锁定,无法访问
3.第一个线程访问完毕,解锁同步监视器
4.第二个线程访问,发现同步监视器没有锁,然后锁定并访词

使用：

 //取钱
    //synchronized 默认锁的是this
    @Override
    public void run() {
        synchronized (account) {
            //判断有没有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() +

                        ",需要取" + drawingMoney +
                        ",钱不足，取不了,手上有" + nowMoney +
                        ",银行剩余：" + account.money);
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额
            account.money = account.money - drawingMoney;//取钱
            //手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(this.getName() +
                    ",取钱:" + drawingMoney +
                    ",成功，手上有：" + nowMoney +
                    ",银行剩余：" + account.money);
        }
    }

用synchronized (account) {}把方法包起来
其中account是账户，默认的是synchronized (this) {}：代码中表现为银行，而把account放入，锁的是开出来的卡，当取钱时卡中余额改变，就形成了锁和解锁过程

附加个List案例

package syn;

import java.util.ArrayList;
import java.util.List;

//线程安全合集
public class UnsafelList {
    public static void main(String[] args) throws InterruptedException {
        List<String >  list = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

补充：JUC

package syn;

import java.util.concurrent.CopyOnWriteArrayList;//并发编程

//测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

死锁

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

package lock;

//死锁- 多个线程互相持有，多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup gril0 = new Makeup(0,"灰姑娘");
        Makeup gril1 = new Makeup(1,"白雪公主");
        gril0.start();
        gril1.start();
    }
}

//口红
class Lipstick {

}

//镜子
class Mirror {

}

//化妆
class Makeup extends Thread {
    //需要的资源，只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    //定义人
    int choice;// 选择
    String girlName;//使用化妆品的人

    Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
    //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    //化妆  互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+ "获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒钟后想获得镜子的锁
                    System.out.println(this.girlName+ "获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+ "获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){//一秒钟后想获得口红的锁
                    System.out.println(this.girlName+ "获得口红的锁");
                }
            }
        }
        
    }
}

◆争严生死锁的四个必要条件

1.互斥条件:一个资源每次只能被一个进程使用
2.请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
3.不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺。
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

上面列出了死锁的四个必要条件,我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

解决方案

 //化妆  互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);

            }
            synchronized (mirror) {//一秒钟后想获得镜子的锁  ---   把这个放出来
                System.out.println(this.girlName + "获得镜子的锁");
            }

        } else {
            synchronized (mirror) {//获得镜子的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);

            }
            synchronized (lipstick) {//一秒钟后想获得口红的锁 ---   把这个放出来
                System.out.println(this.girlName + "获得口红的锁");
            }
        }

    }

Lock(锁)

◆从JK5.0开始,Java提供了更强大的线程同步机制—通过显式定乂同步锁对象来实现同步。同步锁使用Lock对象充当
◆java.uti! concurrent locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
◆ Reentrant!oκk (可重入锁) 类实现了Locκk,它拥有与syη chronized相同的并发性和內存语义,在实现线程安全的控制中,比较常用的是 Reentrantlock,可以显式加锁、释放锁。

package lock;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }

}

class TestLock2 implements Runnable {
    int ticketNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //加锁
                lock.lock();
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            } finally {
                //解锁
                lock.unlock();
            }
        }

    }
}

若程序中有抛出异常
需要把lock.unlock();放入finally {}中，表示执行完是否异常都执行解锁步骤

sychronized和lock的对比

◆Lok是显式锁(手动开启和关闭锁,别忘记关闭锁) synchronized是隐式锁,出了作用域自动释放
◆Lock只有代码块锁,synchronized有代码块锁和方法锁
◆使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类
◆优先使用顺序:

◆Lock>同步代码块(已经进入了方法体,分配了相应资源)>同步方法(在方法体之外)

ok线程同步已经ok了

源码下载 0积分

文件下载: 所有java文件都在这 多线程.

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

轻动琴弦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值