java的线程同步机制与synchronized同步锁方法与死锁与lock锁

最新推荐文章于 2024-04-17 03:55:13 发布
最新推荐文章于 2024-04-17 03:55:13 发布
阅读量367 收藏
点赞数
文章标签： java 多线程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yushenshili/article/details/105302715
版权

线程同步机制
三大不安全案例
同步方法与同步代码块
synchronized(this)同步方法与同步代码块解析
修改三大不安全案例：
JUC并发包的测试JUC安全类型的集合
lock锁和死锁
转链接：多线程详解

线程同步机制

并发：同一个对象被多个线程同时操作
线程同步：多个线程访问同一个对象，并且某些线程还想修改这个对象时，线程同步就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池，形成队列，等待前一个使用完毕，下一个线程再使用
队列和锁：队列和锁保证线程同步的安全性
synchronized锁存在问题（高并发铺垫）：

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

三大不安全案例

不安全买票：


public class UnsafeBuyTicket implements Runnable {

    public static void main(String[] args) {
        UnsafeBuyTicket unsafeBuyTicket = new UnsafeBuyTicket();
        Thread t1 = new Thread(unsafeBuyTicket,"你们");
        Thread t2 = new Thread(unsafeBuyTicket,"我");
        Thread t3 = new Thread(unsafeBuyTicket,"黄牛");
        t1.start();
        t2.start();
        t3.start();
    }
    private int ticketnums=10;
    boolean flag=true;//标识位，标识位是什么，看线程的停止
    @Override
    public void run() {
        //买票
        while (flag) {
            //判断是否有票
            if (ticketnums<=0) {
                return;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到"+ticketnums--);
        }
    }
}

不安全取钱：

//两个人去取钱，两个账户
public class UnsafeBank  {
    public static void main(String[] args) {
        Account account= new Account(100,"结婚基金");
        new Drawing(account,50,"你").start();
        new Drawing(account,100,"你女朋友").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 drawmoney;
    int nowmoney;//现在手里有多少钱

    public Drawing(Account account,int drawmoney,String name){
        super(name);
        this.drawmoney=drawmoney;
        this.account=account;
    }
    //取钱
    @Override
    public void run() {
        if (account.money-drawmoney<0) {
            System.out.println(Thread.currentThread().getName()+"钱不够取不了");
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //卡内余额=余额-取得钱
        account.money=account.money-drawmoney;
        //手里的钱
        nowmoney=nowmoney+drawmoney;
        System.out.println(account.name+"余额为"+account.money);
        System.out.println(Thread.currentThread().getName()+"手里的钱"+nowmoney);

    }
}

不安全列表（不懂lambda表达式看目录链接，多线程详解）：

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();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

同步方法

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

同步方法：public snchronized void method（int args）{}
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，指导该方法返回时才释放锁，后面的被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大的方法声明为synchronized将会影响效率
同步代码块：synchronized（Obj）{}
Obj称之为同步监视器，可以是任何对象，同步方法中不需要Obj，因为同步方法的同步监视器就是this，或者class（反射）

synchronized(this)同步代码块

规则：

  • 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
  • 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
  • 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
  • 四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
  • 五、以上规则对其它对象锁同样适用.
    下面举个简单的例子：
同步代码块
public void run() {
        while (true) {
            synchronized (this) {//同步代码块，在方法中其中this也可以改成“ ”，空字符串形势
                if (num>0) {
                    try {
                        Thread.sleep(500);
                        System.out.println(Thread.currentThread().getName()+"票数"+num--);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
同步方法
private synchronized void cell(){//定义方法后在重写的run方法中进行调用
        if (num>0) {
            try {
                Thread.sleep(500);
                System.out.println(Thread.currentThread().getName()+"票数"+num--);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
完整的同步代码块代码
public class synchronizedpractice implements Runnable {
    int num =20;
    public static void main(String[] args) {
    synchronizedpractice sy=new synchronizedpractice();
    Thread t1=new Thread(sy,"线程1");
    Thread t2=new Thread(sy,"线程2");
    Thread t3=new Thread(sy,"线程3");

    t1.start();
    t2.start();
    t3.start();

    }
    public void run() {
        while (true) {
            synchronized (this) {
                if (num>0) {
                    try {
                        Thread.sleep(500);
                        System.out.println(Thread.currentThread().getName()+"票数"+num--);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
完整的同步方法代码
public class synchronizedpractice implements Runnable {
    int num =20;
    public static void main(String[] args) {
    synchronizedpractice sy=new synchronizedpractice();
    Thread t1=new Thread(sy,"线程1");
    Thread t2=new Thread(sy,"线程2");
    Thread t3=new Thread(sy,"线程3");

    t1.start();
    t2.start();
    t3.start();
    }

    private synchronized void cell(){//构造私有
        if (num>0) {
            try {
                Thread.sleep(500);
                System.out.println(Thread.currentThread().getName()+"票数"+num--);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void run() {
        while (true) {
            this.cell();//这个地方用的this指调用本类的被隐藏的方法
        }
    }
}

修改三大不安全案例：
买票安全：

class UnsafeBuyTicket implements Runnable{
    public static void main(String[] args) {
        UnsafeBuyTicket unsafeBuyTicket = new UnsafeBuyTicket();
        new Thread(unsafeBuyTicket,"自己").start();
        new Thread(unsafeBuyTicket,"你").start();
        new Thread(unsafeBuyTicket,"黄牛").start();
    }
    int TicketNuns=10;
    boolean flag=true;
//买票
    @Override
    public void run() {
        while (flag) {
            Buy();
        }
    }
    //同步方法，锁的是this（UnsafeBuyTicket）
    private synchronized void Buy(){
        if (TicketNuns<=0) {
            return;
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买了第"+TicketNuns--+"张票");

    }
}

取钱安全：


//两个人去取钱，两个账户
public class UnsafeBank  {
    public static void main(String[] args) {
        Account account= new Account(100,"结婚基金");
        new Drawing(account,50,"你").start();
        new Drawing(account,100,"你女朋友").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 drawmoney;
    int nowmoney;//现在手里有多少钱

    public Drawing(Account account,int drawmoney,String name){
        super(name);
        this.drawmoney=drawmoney;
        this.account=account;
    }
    //取钱
    @Override
    public void run() {
        //同步代码块,要锁账户，默认是锁本身哟，
        // 本身是银行哟，就是this哟，所以这里要用代码块
        //锁的就是变化的量,需要增删改查的对象
        synchronized (account){
            if (account.money-drawmoney<0) {
                System.out.println(Thread.currentThread().getName()+"钱不够取不了");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡内余额=余额-取得钱
            account.money=account.money-drawmoney;
            //手里的钱
            nowmoney=nowmoney+drawmoney;
            System.out.println(account.name+"余额为"+account.money);
            System.out.println(Thread.currentThread().getName()+"手里的钱"+nowmoney);

        }




    }
}

集合安全：

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(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}
JUC并发包的测试JUC安全类型的集合
import java.util.concurrent.CopyOnWriteArrayList;
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());
            });
        }
        System.out.println(list.size());
    }
}
死锁：

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

//一句话，相互想要对方的东西，坚持着，谁也不给
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"灰姑娘");
        Makeup g2=new Makeup(2,"白雪公主");
        g1.start();
        g2.start();
    }

}
//口红
class Lipstick{

}
//镜子
class Mirror{

}
//化妆
class Makeup extends Thread{

    //需要的资源只有一份，用static来保证只有一份，用static是因为这样两个线程才是拿的同一个口红和镜子
    static Lipstick lipstick=new Lipstick();
    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() {
        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 + "获得口红的锁");
            }
        }

        }
    }
}

结果：僵持
在这里插入图片描述
发生死锁就是因为抱着对方的锁不放，这个时候把他拿出来，就可以解决问题：

//一句话，相互想要对方的东西，坚持着，谁也不给
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"灰姑娘");
        Makeup g2=new Makeup(2,"白雪公主");
        g1.start();
        g2.start();
    }

}
//口红
class Lipstick{

}
//镜子
class Mirror{

}
//化妆
class Makeup extends Thread{

    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick=new Lipstick();
    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() {
        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 + "获得口红的锁");
            }

        }
    }
}

结果：
在这里插入图片描述

避免死锁的四个必要条件：

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

强大的线程同步机制，通过显式定义同步锁对象来实现同步（synchronized是隐式的），关键词lock。
也是属于juc并发的领域，java.util.concurrent.locks.Lock接口。
ReentrantLock类实现了Lock（可重入锁）。
Lock锁只有代码块锁，synchronized有代码块和方法锁
使用lock锁，JVM将花费少量时间来调度线程，性能更好和扩展性

import java.util.concurrent.locks.ReentrantLock;

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) {
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"拿了第"+TicketNums--+"票");

            }finally {
                lock.unlock();//解锁,如果同步代码快有异常，要将unlock放在finally语句块
            }
        }
    }
}

更多安全锁，请看单例模式与锁，关联性问题哟
本文记录java复习过程，喜欢点击关注，会持续更新

朝依飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java volidate线程安全_同步（一）
weixin_33558072的博客
03-07 258
一、同步的基本概念1、同步的场景线程获取同步锁，获取失败则阻塞等待，获取成功则执行任务，执行完毕后释放锁。2、线程安全问题(1)内存读取cpu在内存读取数据时，顺序优先级：寄存器-高速缓存-内存计算完成后缓存数据写回内存中(2)可见性每个线程都有独立的工作内存，并对其他线程是不可见的。线程执行如用到某变量，将变量从主内存复制到工作内存，对变量操作完成后再将变量写回主内存。可见性就是指线程A对某变量...
synchronized 和 Lock详解总结
闫兆昌的博客
04-27 4659
1 synchronized 和 Lock的区别 a)存在层次 synchronized是关键字，在jvm层面上，由内置语言实现。 Lock是接口、类。 b) 锁的释放 synchronized在线...
Synchronized锁详解
lixiangchibang的博客
07-31 4700
Synchronized锁详解
Synchronized锁详解(全网最细)
最新发布
Anakki的博客
04-17 1944
正常来说a获取到锁后b不能获取锁，但是当一个实例内的a方法和b方法都是用一把锁上锁时，同一个线程访问a和b就需要重入的能力，比如在a方法中访问b方法，那么a的锁x已经被抢占了，如果不支持重入，那么访问b的时候会发现x锁已经被自己抢占而无法访问，支持重入的原理也就是在这里判断一下当前方法的锁是否是本线程拥有的锁。所以锁消除可以节省毫无意义的请求锁的时间。JVM在JDK1.6后会有几种状态，线程获取对象时，分别会判断对象锁的状态，以此来决定线程是否进入阻塞，或者获取到锁对象执行代码块，或者自旋等接下来的动作。
synchronized的几种加锁方式
x1107761900的博客
03-21 1万+
1、修饰普通方法（锁住的是当前实例对象） 同一个实例调用会阻塞 不同实例调用不会阻塞 public class SynchronizedTest { //锁住了本类的实例对象 public synchronized void test1() { try { logger.info(Thread.currentThread().getName...
Java--多线程之synchronized和lock；死锁（四）
MinggeQingchun的博客
10-12 1034
在了解synchronized之前，我们先看一个线程不安全的示例如一个账户中有1万块钱，两个人同时取钱，会导致余额不对，或者取的钱比账户中金额还多输出如下t1和t2线程分别在同一个总金额为1万的账户取款 5千，然余额还是5千，这就导致了多线程并发下数据不安全的情况。
Java多线程 线程同步与死锁
08-30
Java多线程 线程同步与死锁 Java多线程是一种编程技术，允许多个线程同时执行，以提高程序的执行效率和响应速度。但是，多线程编程也存在一些安全问题，例如线程同步和死锁问题。 线程同步是指多个线程之间的协作...
深入解析Java并发程序中线程的同步与线程锁的使用
09-02
`synchronized`关键字是Java内置的同步机制，它提供了两种形式：synchronized方法和synchronized代码块。synchronized方法是通过在方法签名前添加`synchronized`来声明，这样任何线程在访问该方法时都需要获取到对象...
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
* Lock对象是Java中的一个锁机制，提供了比synchronized方法和语句更好的性能和灵活性。 * Lock对象可以用来解决线程同步问题，提供了比synchronized方法和语句更好的性能和灵活性。 * 在使用Lock对象时，需要注意锁...
Java线程唤醒与阻塞常用方法共2页.pdf.zip
10-28
- `synchronized`: 通过在代码块或方法上使用`synchronized`关键字，可以实现线程同步，确保同一时间只有一个线程可以访问特定的代码段，从而避免数据不一致。 - `ReentrantLock`: Java并发包中的`java.util....
java的线程同步机制synchronized关键字的理解_.docx
10-09
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
详解Java中synchronized关键字的死锁和内存占用问题
09-02
Java的synchronized关键字用来进行线程同步操作,然而这在使用中经常会遇到一些问题,这里我们就来详解Java中synchronized关键字的死锁和内存占用问题:
synchronized锁（方法锁, 代码块锁）
Lucifer ZHAO
05-16 5761
synchronized锁可以解决线程安全问题，但是相应的，只要是锁，就会带来性能开销，所以尽可能减小锁的范围尤为重要。 synchronized锁无非修饰普通方法，修饰静态方法，修饰代码块，我认为无非就两种（对象锁、类锁），只不过是锁的使用对象不同而已，实际上synchronized锁的作用范围，取决于使用对象的生命周期。接下来简单介绍几种不同影响范围的锁。...
java全局变量加锁_Java锁Synchronized，对象锁和类锁举例
weixin_42124743的博客
02-13 2347
4. 同步加锁的是对象，而不是代码。因此，如果你的类中有一个同步方法，这个方法可以被两个不同的线程同时执行，只要每个线程自己创建一个的该类的实例即可。5.不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。6. synchronized关键字是不能继承的，也就是说，基类的方法synchronized ...
详解synchronized与Lock的区别与使用
热门推荐
brickworkers的博客
03-22 21万+
引言： 昨天在学习别人分享的面试经验时，看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是，我整理了两者的区别和使用情况，同时，对synchronized的使用过程一些常见问题的总结，最后是参照源码和说明文档，对Lock的使用写了几个简单的Demo。请大家批评指正。 技术点： 1、线程与进程： 在开始之前先把进程与线程进行区分一下，一个程序最...
Java死锁（synchronized）
u013654847的博客
07-24 510
Java死锁（synchronized）
Synchronized和lock锁的区别
欢迎一起学习交流
04-12 289
锁 Synchronized lock 层级 java关键字，在jvm层面上 一个类 锁的释放 锁中的同步代码块执行完后会释放锁 使用try{}catch{}finally{}手动释放 锁的获取 线程1获取锁之后，线程2会进行等待 Lock类中有一个tryLock()方法，尝试获取锁，lock锁的线程不一定需要等待 锁状态 无法判断 可以判断 锁类型 可重入锁、不可中断、非公平锁 可重入锁、可判断、非公平锁/...
同步锁基本原理与实现，看这篇就够了！
吧主
12-02 2187
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文No matter when you start, it is impo...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
案例演示了如何使用`Lock`来避免死锁，例如，我们可以用`ReentrantLock`替代`synchronized`，改变锁的获取顺序，或者使用`tryLock()`方法设置超时，确保线程在一定时间内获得锁，从而避免死锁的发生。总结来说，理解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值