线程同步+锁

2021-10-20 21:30:55 阅读：333 来源： 互联网

标签：account 同步 Thread synchronized 线程 new public

线程同步

含义

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

形成条件：队列+锁

锁(synchronized隐式锁)

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

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

不安全线程测试

package com.Thread;
//不安全线程测试
public class UnSafeTest {
    public static void main(String[] args) {
    //账户
        Account account=new Account(100,"结婚基金");
        Drawing you =new Drawing(account,50,"你");
        Drawing me =new Drawing(account,100,"我");
        you.start();
        me.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()+"钱不够，取不了");
           return;
       }
       //sleep可以放大问题的发生性
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额
        account.money=account.money-drawingMoney;
        //你手里的钱
        nowMoney=nowMoney+drawingMoney;
        System.out.println(account.name+"余额为"+account.money);
        System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
}

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块
synchronized方法控制对“对象”的访问，每个对象一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
**缺陷：**若将一个大的方法声明为synchronized将会影响效率

同步块

在这里插入图片描述
同步线程测试：

package com.Thread;
//不安全线程测试
public class UnSafeTest {
    public static void main(String[] args) {
    //账户
        Account account=new Account(100,"结婚基金");
        Drawing you =new Drawing(account,50,"你");
        Drawing me =new Drawing(account,100,"我");
        you.start();
        me.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() {
    //锁的对象就是变化的量，需要增删改的对象
        synchronized (account){
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }
            //sleep可以放大问题的发生性
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额
            account.money=account.money-drawingMoney;
            //你手里的钱
            nowMoney=nowMoney+drawingMoney;
            System.out.println(account.name+"余额为"+account.money);
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
        }

}

哪个类的属性会发生变化，就锁哪个类的对象

JUC安全类型测试(java.util.concurrent)

锁(Lock 显示锁)

ReenTrantLock(可重入锁)类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁

package com.Thread2;

import java.util.concurrent.locks.ReentrantLock;

public class JUCLock {
    public static void main(String[] args) {
        Lock lock =new Lock();
        new Thread(lock).start();
        new Thread(lock).start();
        new Thread(lock).start();


    }

    static class Lock implements Runnable{
    private  final  ReentrantLock lock=new ReentrantLock();
        int ticketName=10;

        @Override
        public void run() {
          lock.lock();
            try {
                while (true){                  
                    if (ticketName>0){
                        System.out.println(ticketName--);
                    }
                    else {
                        break;
                    }
                }
            }finally {
                lock.unlock();
            }

    }
    }
}

注意：开锁和关锁要在try finally进行。

在这里插入图片描述

集合

package com.Thread2;

import java.util.concurrent.CopyOnWriteArrayList;
//测试juc安全类型的集合
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
       CopyOnWriteArrayList<String> list =new CopyOnWriteArrayList();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
            list.add(Thread.currentThread().getName());

            }).start();
        }
        Thread.sleep(1000);
        System.out.println(list.size());

    }

}

synchronized与Lock的对比

1.Lock是显示锁(手动开启和关闭锁，别忘记关闭锁)synchronized是隐式锁，出了作用域自动释放
2.Lock只有代码块锁,synchronized有代码块锁和方法锁
3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多子类)
4.优先顺序：
Lock>同步代码块(已经进入了方法体，分配了相应资源)>同步方法(在方法体之外)

死锁

含义

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

避免方法

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

死锁演示：
原因：同时用一个资源

package com.Thread2;

public class DeadLock {
    public static void main(String[] args) {
        MakeUp makeUp=new MakeUp(0,"伤心小女孩");
        MakeUp makeUp1=new MakeUp(1,"恶毒老太婆");
     makeUp.start();
     makeUp1.start();



    }
    static class  LipsSick{

    }
    static   class Mirror{

     }

 static class MakeUp extends Thread{
        //需要的资源只有一份，用static保证只有一份
     static  LipsSick lipsSick=new LipsSick();
     static  Mirror  Mirror=new Mirror();

        int choice;
        String girlName;
        public MakeUp(int choice,String girlName){
            this.choice=choice;
            this.girlName=girlName;
        }
        @Override
        public void run() {
            makeup();
        }
        //互相持有对方的锁，竞争同一块资源，形成死锁
       private void  makeup(){
        if (choice==0){
           synchronized (lipsSick){
               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 (lipsSick){
                    System.out.println(this.girlName+"镜子拿到了");
                }
            }

        }

        }

    }
}

解锁：

package com.Thread2;

public class DeadLock {
    public static void main(String[] args) {
        MakeUp makeUp=new MakeUp(0,"伤心小女孩");
        MakeUp makeUp1=new MakeUp(1,"恶毒老太婆");
     makeUp.start();
     makeUp1.start();



    }
    static class  LipsSick{

    }
    static   class Mirror{

     }

 static class MakeUp extends Thread{
        //需要的资源只有一份，用static保证只有一份
     static  LipsSick lipsSick=new LipsSick();
     static  Mirror  Mirror=new Mirror();

        int choice;
        String girlName;
        public MakeUp(int choice,String girlName){
            this.choice=choice;
            this.girlName=girlName;
        }
        @Override
        public void run() {
            makeup();
        }
       private void  makeup(){
        if (choice==0){
           synchronized (lipsSick){
               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 (lipsSick){
                System.out.println(this.girlName+"镜子拿到了");
            }

        }

        }

    }
}

ps:b站狂神笔记

标签：account,同步,Thread,synchronized,线程,new,public
来源： https://blog.csdn.net/fhuqw/article/details/120827188

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

ICode9