Java-多线程(三)-线程同步、多线程并发案例、线程同步的加锁方法、死锁

最新推荐文章于 2024-02-23 13:36:39 发布
最新推荐文章于 2024-02-23 13:36:39 发布
阅读量372 收藏 1
点赞数
文章标签： java 多线程 lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45658089/article/details/115438139
版权

Java-多线程-3

学习视频：B站 狂神说Java – https://www.bilibili.com/video/BV1V4411p7EF

学习博客：csdn – https://blog.csdn.net/qijingwang/article/details/104892717

学习博客：csdn – https://blog.csdn.net/yalu_123456/article/details/91050036?spm=1001.2014.3001.5501

8、线程同步规则

8.1、线程简介及多线程的影响

我们先回顾一下线程。

线程：进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个程序至少有一个进程。线程是CPU调度和执行的单位。

一个进程中会有一个或多个线程，这些线程会共享进程的资源，但又有各自的程序计数器、栈和局部变量表。同一进程中的不同线程能够访问相同的变量，并且在同一个堆上分配对象。这样就会产生不同的正负作用影响。

优势（正作用）：

  • 提高程序的运行性能。
  • 充分利用系统的处理能力，提高系统的资源利用率。
  • 提高系统响应性，即线程可以在运行现有任务的情况下立即开始处理新的任务。

问题（负作用）：

  • 安全性问题：即并发问题，共享进程资源，访问相同变量，却有各自的程序计数器、栈和局部变量表， 这会造成对同一对象分配处理时，状态变量改变了 或者 没有及时改变，发生数据紊乱现象。
  • 活跃性问题：不正确的加锁、解锁方式可能会导致死锁or活锁问题。
  • 性能问题：多线程并发即多个线程切换运行，线程切换会有一定的消耗并且不正确的加锁。

8.2、线程同步规则

并发

并发：同一个对象被多个线程同时操作。 这样造成了数据紊乱。如下图例：
在这里插入图片描述

线程同步

现实生活中,我们会遇到 ” 同一个资源 , 多个人都想使用 ” 的问题 , 比如,食堂排队打饭 , 每个人都想吃饭 , 最天然的解决办法就是 , 排队 . 一个个来.

在这里插入图片描述

这种所有人都去共享 饭资源，就好比是多线程。 在处理多线程并发问题时，我们可以借鉴排队打饭这种方法。 多个线程访问同一个对象 , 并且某些线程还想修改这个对象 .这时候我们就需要线程同步 . 线程同步其实就是一种等待机制 , 多个需要同时访问此对象的线程进入这个对象的等待池 形成队列, 等待前面线程使用完毕 , 下一个线程再使用。

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

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

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

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

多个线程访问同一对象，造成并发问题。

队列和锁 才能去完成线程同步，解决线程并发的安全问题，但是性能就会差。

9、三大不安全案例

9.1、不安全的买票案例

在买票的时候， 多个线程去对买票这个进程中的共享资源 票数 进行共享，但是由于每个线程有各自的程序计数器、虚拟机栈和本地方法栈、局部变量表，导致数据资源改变，状态不一致，造成了数据紊乱。

我们采用sleep()方法模拟延时，放大问题的发生性。

例子：不安全的买票，代码：

package com.AL.Multithread;

// 线程不安全，数据紊乱。
// 不安全的买票。 会出现票数为负
public class UnsafeBuyTicket {
    public static void main(String[] args){
        BuyTicket station = new BuyTicket();

        new Thread(station,"可怜的我").start();
        new Thread(station,"得意的你").start();
        new Thread(station,"可恶的黄牛党").start();
    }
}

class BuyTicket implements Runnable{
    // 票数
    private int ticketNums = 10;
    boolean flag = true; // 外部停止方式，标志位
    @Override
    public void run() {
        // 买票
        while (flag){
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    // 买票，这一部分是为了去改变 flag，便于线程停止
    private void buy() throws InterruptedException{
        // 判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时。  可以放大  问题的发生性
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
    }
}

结果：票数出现重复，有时为负数。这种错误的原因是：每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。 这就是线程不安全的一个例子。

得意的你拿到了8
可怜的我拿到了9
可恶的黄牛党拿到了10
可怜的我拿到了7
得意的你拿到了5
可恶的黄牛党拿到了6
得意的你拿到了4
可恶的黄牛党拿到了4
可怜的我拿到了3
得意的你拿到了2
可怜的我拿到了1
可恶的黄牛党拿到了2

9.2、不安全的取钱案例

不安全的取钱案例： 并发问题，数据紊乱，线程不安全。

对于银行这个类来讲，会有账户；会有两个人去取钱，即对应着 多个线程对同一个资源对象进行操作。而这两个人即两个线程会由于各自本身具有程序计数器，内存空间，导致这同一个对象分别在两个线程中的状态变量不能同步更新， 从而造成数据紊乱。

代码：

package com.AL.Multithread;

//不安全的取钱
// 两个人去银行取钱， 账户
public class UnsafeBank {
    public static void main(String[] args){
        //账户
        Account account = new Account(100,"结婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"女朋友");
        you.start();
        girlFriend.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;
        }
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 卡内余额 = 余额-你取的钱
        account.money = account.money - drawingMoney;
        // 你手里的钱
        nowMoney= nowMoney + drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱:"+nowMoney);
    }
}

结果：这出现错误，账户金额为负数。

结婚基金余额为：-50
结婚基金余额为：-50
女朋友手里的钱:100
你手里的钱:50

9.3、不安全的集合案例

例子：

package com.AL.Multithread;

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

public class UnSafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();

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

        for (int i = 5;i>0;i--){
            Thread.sleep(1000);
            System.out.println("倒计时"+i);
        }

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

结果： 结果中没有到达100000，线程不安全。

倒计时5
倒计时4
倒计时3
倒计时2
倒计时1
99974

10、同步方法及同步块

10.1、同步方法：

同步方法：

  • 由于我们可以通过 private 关键字来保证数据对象只能被方法访问 , 所以我们只需要针对方法提出一套机制 , 这套机制就是 synchronized 关键字 , 它包括两种用法 :synchronized 方法 和synchronized 块 。
    同步方法 : public synchronized void method(int args) {}

  • synchronized方法控制对 “对象” 的访问 , 每个对象对应一把锁 , 每个synchronized方法都必须获得调用该方法的对象的锁才能执行 , 否则线程会阻塞 ；
    方法一旦执行 , 就独占该锁 , 直到该方法返回才释放锁 , 后面被阻塞的线程才能获得这个锁 , 继续执行；
    缺陷 : 若将一个大的方法申明为synchronized 将会影响效率

同步方法的弊端：
方法里面需要修改的内容才需要锁,
锁的太多 , 浪费资源

10.2、同步块：

  • 同步块 : synchronized (Obj ) { }

  • Obj 称之为 同步监视器

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

  • 同步监视器的执行过程

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

10.3、加锁的买票案例

使用synchronized 方法去控制对"对象"的访问， 此时对 买票 这个方法进行加锁.

那么从此时对buy()方法添加关键词synchronized 后为 private synchronized void buy() 相当于锁住。

同步方法避免了线程不安全的问题，如数据紊乱的问题避免了。

package com.AL.Multithread;

// 线程不安全，数据紊乱。
// 不安全的买票。 会出现票数为负
public class UnsafeBuyTicket {
    public static void main(String[] args){
        BuyTicket station = new BuyTicket();

        new Thread(station,"可怜的我").start();
        new Thread(station,"得意的你").start();
        new Thread(station,"可恶的黄牛党").start();
    }
}

class BuyTicket implements Runnable{
    // 票数
    private int ticketNums = 10;
    boolean flag = true; // 外部停止方式，标志位
    @Override
    public void run() {
        // 买票
        while (flag){
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    // 买票，这一部分是为了去改变 flag，便于线程停止
    //private void buy() throws InterruptedException{
    private synchronized void buy() throws InterruptedException{//添加关键词synchronized,相当于锁住，同步方法.避免了线程不安全的问题，如数据紊乱的问题避免了
        // 判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时。  可以放大  问题的发生性
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
    }
}

结果：

可怜的我拿到了10
可怜的我拿到了9
可怜的我拿到了8
可怜的我拿到了7
可恶的黄牛党拿到了6
可恶的黄牛党拿到了5
得意的你拿到了4
得意的你拿到了3
得意的你拿到了2
得意的你拿到了1

10.4、加锁的银行取钱案例

在取钱的这个例子中， 我们能直接对取钱的 run 方法这里添加关键词后为： public synchronized void run() ， 但是结果仍然有问题， 因为在这个run方法中，默认锁住的是 this。

取钱的例子结果表明，我们没有完全锁住。 我们应该去锁住 account这个账户，修改如下：即采用synchronized(Obj)块去解决。锁的对象应该是 增删查改的对象，即不是锁银行，应该是锁账户。

package com.AL.Multithread;

//不安全的取钱
// 两个人去银行取钱， 账户
public class UnsafeBank {
    public static void main(String[] args){
        //账户
        Account account = new Account(100,"结婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"女朋友");
        you.start();
        girlFriend.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) { //Synchronized(Obj){}同步块，锁住增删查改的对象
            //判断有没有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 卡内余额 = 余额-你取的钱
            account.money = account.money - drawingMoney;
            // 你手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name + "余额为：" + account.money);
            System.out.println(this.getName() + "手里的钱:" + nowMoney);
        }
    }
}

结果：

结婚基金余额为：50
你手里的钱:50
女朋友钱不够，取不了

10.5、集合的案例

JUC并发编程,保护线程安全的一些类。

package com.AL.Multithread;

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

public class SafeList {
    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();
        }

        for (int i = 5;i>0;i--){
            Thread.sleep(1000);
            System.out.println("倒计时"+i);
        }
        System.out.println(list.size());
    }
}

或者我们可以选择能够保证线程安全的List， 即使用 CopyOnWriteArrayList。如下所示：

package com.AL.Multithread;

import java.util.concurrent.CopyOnWriteArrayList;

public class SafeJUCList {
    public static void main(String[] args) throws InterruptedException {
        //保证线程安全的list , ArrayList
        CopyOnWriteArrayList list = new CopyOnWriteArrayList();

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

        for (int i = 5;i>0;i--){
            Thread.sleep(1000);
            System.out.println("倒计时"+i);
        }
        System.out.println(list.size());
    }
}

上述两种方法都能解决集合List的线程安全问题，结果如下：

倒计时5
倒计时4
倒计时3
倒计时2
倒计时1
100000

11、死锁

死锁

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

两个或多个线程都在等待对方释放资源，结果产生了都停止执行的情形，即死锁。

产生死锁的四个必要条件：

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

死锁避免方法：我们只要将这四个必要条件破坏掉任意一个就可以避免死锁发生。

例子：多个线程去共用同一个资源，多个线程互相拥抱着对方需要的资源，然后形成僵持，造成了死锁。

在灰姑娘或者白雪公主任意一个进程去进行多线程时， 因为它们各自都会紧握着对方需要的那个锁的资源，你在抱着这两个锁的资源时，还想让对方给你想要的，对方并没有得到。

拿了镜子的锁，里面还包含想要口红的锁；但是有了口红的锁，还包含着镜子的锁，这就造成了同一资源被两个进程调用。所以就造成了死锁。

为了避免死锁，白雪公主或者灰姑娘，在已经拥有一个锁的时候，就把另外一个锁放出去，然后等待得到自己想要的锁 资源，就能避免死锁了。

在代码中，注释部分是死锁的案例，即同一资源被两个进程去调用。 将锁修改到外面的代码块， 不让他抱对方的锁，就可以解决问题。

package com.AL.Multithread;

//死锁: 多个线程共用同一个资源。
// 多个线程互相拥抱着对方需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args){
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");

        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 girlNmae; //使用化妆品的人

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

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
/**
    //此时， 同一个资源被两个进程调用，造成了死锁
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) { //设置口红的锁， 同步块
                System.out.println(this.girlNmae + "获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror) { // 一秒钟后想要获得镜子
                    System.out.println(this.girlNmae + "获得镜子的锁");
                }
            }
        } else {
            synchronized (mirror) { // 获得镜子的锁
                System.out.println(this.girlNmae + "获得镜子的锁");
                Thread.sleep(1000);
                synchronized (lipstick) { // 一秒钟后想要获得口红
                    System.out.println(this.girlNmae + "获得口红的锁");
                }
            }
        }
    }
 */
private void makeup() throws InterruptedException {
    if (choice == 0) {
        synchronized (lipstick) { //设置口红的锁， 同步块
            System.out.println(this.girlNmae + "获得口红的锁");
            Thread.sleep(1000);
        }
        synchronized (mirror) { // 一秒钟后想要获得镜子
            System.out.println(this.girlNmae + "获得镜子的锁");
        }
    } else {
        synchronized (mirror) { // 获得镜子的锁
            System.out.println(this.girlNmae + "获得镜子的锁");
            Thread.sleep(1000);
        }
        synchronized (lipstick) { // 一秒钟后想要获得口红
            System.out.println(this.girlNmae + "获得口红的锁");
        }
    }
}
}

结果：

白雪公主获得镜子的锁
灰姑娘获得口红的锁
白雪公主获得口红的锁
灰姑娘获得镜子的锁

12、Lock(锁)

Lock锁

  • JDK5.0开始，java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  • ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

对于Lock（锁），它的语法如下，特别注意的是显示加锁和释放锁；

class A{
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
        lock.lock(); //加锁
        try{
            //保证线程安全的代码;
        }
        finally{
            lock.unlock(); //解锁
            //如果同步代码有异常，要将unlock()写入finally语句块
        }
}

synchronized 与 Lock 的对比：

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

synchronized 与 Lock优先使用顺序：

Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

ReentrantLock类实现了Lock，其中的ReentrantLock称为可重入锁。

下方的例子：买票的案例，注释部分为没有加锁的部分，多线程会发生并发问题，造成数据紊乱。 修改后的代码中，使用了ReentrantLock类，实例化对象为 lock， 然后进行加锁和解锁，保证线程安全性。

package com.AL.Multithread;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
// 使用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;
    @Override
    public void run() {
        while (true){
            if(ticketNums > 0){
                try{
                   Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(ticketNums--);
            }else {
                break;
            }
        }
    }
}
 */
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();
            }
        }
    }
}

结果：

10
9
8
7
6
5
4
3
2
1
AL ZN
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
java并发编程专题（三）----详解线程的同步
08-18
Java并发编程中的线程同步是确保多线程环境下数据一致性与正确性的关键技术。在Java中，线程同步主要是为了避免多个线程同时访问共享资源，从而可能导致数据不一致的问题。本文将深入探讨线程同步的概念、临界区的...
高并发与锁（一）
劝学
10-31 4094
DRP学习中，我们对可能引起并发操作的情况使用了锁，这次先理论上看看并发控制与锁的一些内容吧。     并发控制     在多用户环境中，在同一时间可能会有多个用户更新相同的记录，这会产生冲突。这就是著名的并发性问题。 典型的冲突有：     1、丢失更新（Lost updates）     一个事务的更新覆盖了其它事务的更新结果，就是所谓的更新丢失。例如：用户A把值从6改为2，用户
多线程并发编程中的锁
qq_61353850的博客
05-16 439
1、volatile，修饰的a在1线程执行完后，写回内存刷新了，此时缓存行中的线程2所用的a就被标记为无效了，要再次从内存读取，线程1刷新以后的a。但是他只能保证当前查看的时候是正确的，但是最后的结果是不保证的 总线是传送地址和数据，要先传地址再传数据，这时就将缓存行中的地址也发送出去，而另外的地址就标记为无效 2、缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，也就是避免同时两个刷新回写到内存。 volatile保证最先刷新回内存的是有效的。之后的是无效的 3、线程执行方法相.
Java-线程篇-多线程并发下的锁
const_wu的博客
08-18 804
在计算机体系结构中，多线程是中央处理器 (CPU)（或多核处理器中的单核）在操作系统支持下并发提供多个执行线程的能力。这种方法不同于多处理。在多线程应用程序中，线程共享单个或多个内核的资源，包括计算单元、CPU 缓存和转换后备缓冲区 (TLB)。Java程序是需要运行在Java虚拟机上面的，Java内存模型（Java Memory Model ,JMM）就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。
多线程并发和锁机制原理
weixin_58879477的博客
01-21 960
多线程并发和锁机制原理
《多线程并发控制：选择正确的锁策略》：互斥锁、自旋锁、读写锁、乐观锁、悲观锁
weixin_73077810的博客
02-23 695
本文围绕多线程并发控制中的锁策略展开讨论，详细介绍了互斥锁、自旋锁、读写锁、乐观锁以及它们的选择和使用场景。提出在确定被锁住代码执行时间很短时选择自旋锁，否则使用互斥锁；阐述了自旋锁在单核 CPU 和多核系统下的适用情况；深入解析了读写锁工作原理以及读优先锁、写优先锁、公平读写锁的特点和适用场景；最后说明了乐观锁适用于低冲突概率下的场景，但随着冲突概率上升，不适合使用乐观锁的原因。
java多线程编程之使用Synchronized块同步方法
09-04
Java多线程编程中，`synchronized`关键字是实现线程...总之，`synchronized`关键字是Java中实现线程同步的重要工具，通过合理使用同步方法和同步代码块，我们可以确保多线程环境下的数据一致性，防止并发问题的发生。
Java多线程-Thread类的常用结构及线程优先级
01-27
Java多线程编程是开发高并发应用的基础，其中Thread类是实现多线程的核心类。本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称...
Java多线程-线程的生命周期
01-27
Java多线程中，线程的生命周期是编程中必须理解的重要概念。在JDK1.5之前，线程被划分为五个状态，分别是新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。在JDK1.5及之后，线程的...
Java多线程-线程安全问题练习题
01-30
在Java多线程编程中，线程安全问题是非常关键的概念，它涉及到多个线程访问共享资源时可能出现的数据不一致或异常情况。本题主要通过两个练习题来加深对线程安全的理解。 ### 练习题1：新年倒计时 #### 题目描述 ...
java 多线程-线程通信实例讲解
09-01
Java 多线程是并发编程中的重要概念，它允许程序同时执行多个任务，提升系统效率。线程通信是多线程编程中一个关键的组成部分，它确保线程间能有效地协同工作，避免竞争条件和死锁等问题。在Java中，线程通信主要...
基于Java回顾之多线程同步的使用详解
09-05
在Java编程中，多线程同步是一个关键的概念，用于解决并发执行中的数据一致性问题。线程同步确保了多个线程在访问共享资源时按照预定的顺序或规则进行，防止数据竞争和死锁等异常情况发生。本文将深入探讨线程同步的...
JAVA高质量并发详解,多线程并发深入讲解
最新发布
04-24
本书全面解析了Java并发编程的核心概念、原理和实践，帮助读者深入理解多线程并发编程的精髓，提升编程能力和系统性能。 书中首先介绍了并发编程的基础知识，包括线程的基本概念、线程的生命周期、线程安全等问题。...
java synchronized加载加锁-线程可重入详解及实例代码
08-31
这个特性对于避免死锁非常关键，因为在某些情况下，线程可能需要在同步块内调用其他同步方法。如果没有线程可重入，这些内部调用可能导致死锁，因为线程会被自己的锁阻塞。 总的来说，Java的`synchronized`关键字...
Java线程/多线程-锁-并发
a898712940的博客
06-16 313
Java线程和多线程1.Java线程1.1 什么是线程1.2 什么是多线程1.3 线程的创建1.4 线程的状态和生命周期1.5 线程调度1.6 同步与死锁2. Java锁 1.Java线程 1.1 什么是线程 1.2 什么是多线程 1.3 线程的创建 1.4 线程的状态和生命周期 1.5 线程调度 1.6 同步与死锁 2. Java锁 ...
线程同步及数据安全
qq_52041663的博客
08-30 125
进程 进程是系统进行资源分配和调用的独立单元，每一个进程都有它的”独立”内存空间和系统资源。 线程 线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源 一个进程 – 多线程：各个线程都有不同的分工 线程和进程的关系 进程：进程之间的内存空间和系统资源是独立的 线程：线程之间是共享内存空间和系统资源的 进程中：可以有一条或一条以上的线程 进程里只有一条线程的情况下，这条线程就叫做主线程 进程里有多条线程的情况下，只有一条线程叫做主线程 线程是在进程里的，他们是包裹关系 创建
解决多线程安全问题-无非两个方法synchronized和lock 具体原理以及如何 获取锁AQS算法 (百度-美团)...
03-27 157
本篇文章主要讲了lock的原理 就是AQS算法，还有个姊妹篇 讲解synchronized的实现原理 也是阿里经常问的， 参考：深入分析Synchronized原理(阿里面试题) 一定要看后面的文章，先说结论： 非公平锁tryAcquire的流程是：检查state字段，若为0，表示锁未被占用，那么尝试占用，若不为0，检查当前锁是否被自己占用，若被自己占用，则更新state字段，...
多线程与并发 - 常见的几种锁的实现方式
热门推荐
简单记录一下。
11-25 1万+
正如其名，它是指对数据修改时持保守态度，认为其他人也会修改数据。因此在操作数据时，会把数据锁住，直到操作完成。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。如果加锁的时间过长，其他用户长时间无法访问，影响程序的并发访问性，同时这样对数据库性能开销影响也很大，特别是长事务而言，这样的开销往往无法承受。使用悲观锁的时候，我们要注意锁的级别，MySQL innodb 在加锁时，只有明确的指定主键或（索引字段）才会使用 行锁；否则，会执行 表锁，将整个表锁住，此时性能会很差。
java高级特性 - 多线程基础(1)使用线程
06-28
Java高级特性中的多线程基础是指使用线程来实现并发执行的程序。线程是程序执行的最小单位，可以同时执行多个线程，提高程序的执行效率和响应速度。在Java中，使用Thread类和Runnable接口来创建和启动线程。线程的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值