多线程可见

于 2022-07-30 13:35:50 发布
阅读量179 收藏 1
点赞数
分类专栏： 多线程 文章标签： java jvm 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62476684/article/details/126001121
版权

文章目录

进程和线程

进程和线程的关系

  1. 进程包含线程,一个进程可以有一个线程(主线程),也可以有多个线程,每个线程拥有一份PCB对象
  2. 进程是操作系统分配资源的基本单位,线程是操作系统调度的基本单位.
  3. 每个进程内拥有自己独立的虚拟地址空间和独立的文件描述符表,而一个进程里的所有线程公用进程里的资源,所以同一个进程里的线程会互相影响.

为什么会出现线程

首先 并发编程(1.单核cpu发展遇到瓶颈,为了提高算力,需要多核cpu,就用到了并发编程 2. 有些任务需要"等待IO",在这期间,可以利用并发编程去做其他的事情) 成为刚需, 其次 虽然进程也能实现并发编程,但是线程比进程更加轻量:

  1. 创建线程比创建进程更快
  2. 销毁线程比销毁进程更快
  3. 调度线程比调度进程更快
  4. 使用多线程就是没有了操作系统为进程分配资源的时间

java线程和操作系统线程的关系

操作系统内部实现了线程这样的机制,并对用户层提供了API进行使用,而java的Thread类可以认为就是对操作系统的API进行了进一步的抽象和封装

第一个多线程代码

通过自己的MyThread继承Thread类

class MyThread extends Thread{
    //重写run 明确新创建的线程干啥活
    @Override
    public void run() {
        while(true){
            System.out.println("hello Thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("main");
        Thread thread = new MyThread();
        thread.start();//真正开始创建线程(在操作系统内核中,创造出对应的PCB,PCB加入系统链表,参与调度)

    }
}

第一个并发编程代码

class MyThread extends Thread{
    //重写run 明确新创建的线程干啥活
    @Override
    public void run() {
        while(true){
            System.out.println("hello Thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("main");
        Thread thread = new MyThread();
        thread.start();//真正开始创建线程(在操作系统内核中,创造出对应的PCB,pcb加入系统链表,参与调度)

        while(true){
            System.out.println( "hello main");
            Thread.sleep(1000);
        }
    }
}

我们可以看到,进程由main主线程进入,然后main线程和thread交替进行.
(但是在阻塞一秒后,先唤醒main线程还是thread线程是不确定的,操作系统对线程的调度是随机性的)
在这里插入图片描述

创建线程的多种方法

1.继承Thread类

第一就是上文中创建类继承Thread类,并重写run方法

2.实现Runnable接口

第二种就是实现Runnable接口,并实现其中的run方法,
Runnable接口是个函数式接口,其中只有一个run方法

class MyRnnnable implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("hello myrunnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) throws InterruptedException {

        //解耦合
        //任务内容 和 线程本身 分离开
        Runnable runnable = new MyRnnnable();//创建的runnable定义了任务
        Thread t = new Thread(runnable);//把任务交给thread
        t.start();//start创建具体线程

        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

这样的优点是提高了解耦合度,重写的run方法只是定义了任务内容,然后通过Runnable把描述好的任务交给Thread实例,t.start()完成了线程的创建.

3.匿名内部类

匿名内部类可以说完成了三步: 1.继承 2. 方法的重写 3. 类的实例化

3.1 匿名继承Thread类

public static void main(String[] args) {
        
        //匿名内部类
        //继承  方法重写  实例化
        //只是准备好了    还是需要start创建   因为线程还是需要操作系统创建

        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }
        };
        t.start();
    }

3.2 匿名Runnable接口

public static void main(String[] args) {
        //两步实现
        /*Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();*/

		// 一步实现
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

4. lambda表达式

public static void main(String[] args) {
        //lambda 表达式
        Thread t = new Thread(() -> {
            while(true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

通常选择 Runnable 来写更好一些，来完成更好的解耦.写代码注重 高内聚，低耦合.Runnable 单纯的只是描述了一个任务.

多线程节约时间

我们利用单线程和多线程来计算两个变量的自增,从0自增到20亿,并记录两个线程各自的时间来完成比较. 不过,此代码的时间戳在main线程中,为了完成多线程时间的记录,我们需要在main线程中调用t1.join和t2.join 来让main线程等待t1和t2线程执行完毕.

public class Demo {
    private static final long COUNT = 20_0000_0000;
    private static void serial(){
        //把方法执行时间记录
        //记录当前的毫秒时间
        long beg = System.currentTimeMillis();

        int a = 0;
        for(long i = 0; i < COUNT; i++){
            a++;
        }
        a = 0;

        for(long i = 0; i < COUNT; i++){
            a++;
        }

        long end = System.currentTimeMillis();
        System.out.println("单线程消耗时间: " + (end - beg) +" ms");

    }

    private static void concurrency(){
        long beg = System.currentTimeMillis();
        Thread t1 = new Thread(() -> {
           int a = 0;
            for (long i = 0; i < COUNT; i++) {
                a++;
            }
        });

        Thread t2 = new Thread(() ->{
            int a = 0;
            for(long i = 0; i < COUNT;i++){
                a++;
            }
        });

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

        try{
            t1.join();
            t2.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("双线程执行事件:" + (end - beg)+ " ms");
    }
    public static void main(String[] args) {
        concurrency();
        serial();
    }
}

在这里插入图片描述
由此我们可以见到多线程确实对时间完成了优化,那么为什么不是完全的优化一半时间呢? 这是因为线程的创建也需要占用时间.

Thread类的属性和方法

创建线程对象的同时命名

利用Thread的构造方法可以对线程进行命名,如下将线程命名为 张三

public static void main(String[] args) {
        Thread t = new Thread(() ->{
            while(true){
                System.out.println("Thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Thread");
        t.start();
    }

使用jconsole.exe来查看java进程

打开jdk文件夹下bin包中的jconsole.exe
在这里插入图片描述
右键以管理员身份运行,此时就可以看到正在运行的进程
在这里插入图片描述
点击连接后,大胆的选择不安全的连接
在这里插入图片描述
之后就可以得到我们创建的线程的信息
在这里插入图片描述

isDaemon 是否为后台程序

线程分为后台线程和前台线程,进程在执行完所有的前台线程后就会退出进程,而不管后台线程是否执行完毕.

线程启动 start

start决定了一个线程真正的启动,而run方法只是定义了线程要完成的任务

public class Demo8 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello MyThread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "MyThread");
        t.start();

        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

在这里插入图片描述
如此可见 start启动线程后 ,t线程和main线程随机执行
但是如果只调用run方法的话

public class Demo8 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello MyThread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "MyThread");
        t.run();

        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

在这里插入图片描述
可见只调用run方法的话,只是在main线程中调用了一个方法,并没有启动新的线程.

中断线程

在线程执行过程中,如果发生问题我们可以中断线程

手动设置标志位控制线程结束

设置isQuit变量来控制线程的结束

 private static boolean isQuit = false;

    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            while(!isQuit){
                System.out.println("线程运行中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("新线程执行结束");
        });

        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("控制新线程退出");
        isQuit = true;

    }

使用Thread内置的标志位

1.Thread.interrupted() 是Thread类的静态方法 它的返回值是boolean, 他在默认情况下返回值是false,当在使用 thread 对象的 interrupted() 方法通知线程结束时,Thread.interruped的标志位变成true,然后在变回false.
2.Thread.currentThread().isInterrupted() 是Thread的实例方法, Thread.currentThread()返回的是当前Thread类的实例.

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() ->{
            while(!Thread.currentThread().isInterrupted()){//获取到当前线程的实例  判断内置的标志位
                System.out.println("线程运行中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("即将退出");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                    System.out.println("退出");
                    //break;
                }
            }
        });
        t.start();

        Thread.sleep(5000);
        System.out.println("控制新线程退出");
        t.interrupt();//对线程内部进行操作,若处于sleep阻塞状态,则会以 InterruptedException 异常的形式通知，清除中断标志,否则是对内置标志位进行操作

    }

当出现InterruptedException是,是否结束线程取决于catch()内部的写法,可以忽略,也可以选择结束

jion线程等待

多个线程之间的执行顺序是不一定的,我们无法彻底决定调度器调度哪个线程,但是我们可以使用一些手段,来决定谁是先执行的,使用join()实例方法

哪个线程调用的join,哪个线程就会优先执行,一直到调用join线程的run方法执行完毕

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() ->{
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        });

        System.out.println(t.getState());
        t.start();
        t.join();

        System.out.println(t.getState());
    }

在这里插入图片描述

线程的状态

java中线程的状态是一个枚举类型

  1. NEW:任务分配完毕,但是线程还未启动的,即还未调用start方法的
  2. TERMINATED:工作完成了的,即线程的run方法执行完毕
  3. RUNNABLE:可工作的,即就绪的线程,为正在工作中或马上要进行工作的线程
  4. TIMED_WAITING:调用sleep()进入排队
  5. BLOCKED:表示当前线程在等待索,也是在排队
  6. WAITING:线程等待被唤醒状态,
    在这里插入图片描述

线程的安全

如果多线程代码运行的效果符合我们的预期想法,即在单线程下运行的效果,我们就认为线程是安全的

引起线程不安全主要有以下几个原因:
1.因为线程是抢占式执行,随机调度的,这是造成线程不安全的主要原因
2.多个线程对同一个变量进行修改操作
3.操作方式不是原子性的,会造成线程不安全
4.内存可见性问题(可见性指,一个线程对共享变量进行多次修改时,其他线程能及时的读取到修改后的变量的值.)
5.指令重排序:其是指在一段代码中,JVM、CPU指令集会对其进行优化,从而达到时间的更好地效率,这在多线程的情况下很可能使逻辑和之前不对等.

操作方式非原子的线程不安全

我们对同一个共享变量,使用两个线程对其分别进行50000次增加,最后来看一下变量的数值

class Counter{
    public int count;

    public void increase(){
        count++;
    }
}
public class Demo13 {
    public static Counter counter = new Counter();


    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() ->{
            for(int i = 0; i < 50000; i++){
                counter.increase();
            }
        });

        Thread t2 = new Thread(() ->{
            for(int i = 0; i < 50000; i++){
                counter.increase();
            }
        });

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

        t1.join();
        t2.join();

        System.out.println("count: "+ counter.count);
    }
}

在这里插入图片描述
由此我们可以看到结果并不是我们预想的10万,这就是出现了线程安全的问题,
但是为什么是这样呢?

原因

这是因为count++ 其实是三个指令:
1.将内存中的count值读取到CPU的寄存器中
2.CPU的寄存器完成 +1 的运算
3.将寄存器中count的值重新读取到内存中

但是因为抢占式执行,随机调度的原因,两个线程的三个步骤执行可能会有很多种情况,
在这里插入图片描述
在这种情况时,t1线程 load 后,一个寄存器中count的值为0,
t2 load add save后,另一个寄存器中count的值为1,内存中count的值也变为1,
此时t1线程 add save后 寄存器中的count值为1,内存中count的值还为1,
这时,两个线程分别进行了count的自增,但是count的值为1.

这就出现了线程不安全的问题

解决

像这种情况,我们就需要加锁()来解决问题, 通过synchronized加锁,使代码的执行变成原子的(就是整体的 将加锁中的代码完全执行完,才可以变换为令一个线程)

class Counter{
    public int count;

    public synchronized void increase(){
        count++;
    }
}
public class Demo13 {
    public static Counter counter = new Counter();


    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() ->{
            for(int i = 0; i < 50000; i++){
                counter.increase();
            }
        });

        Thread t2 = new Thread(() ->{
            for(int i = 0; i < 50000; i++){
                counter.increase();
            }
        });

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

        t1.join();
        t2.join();

        System.out.println("count: "+ counter.count);
    }
}

在这里插入图片描述

synchronized 用法

synchronized的意思使"同步",其在不同的环境中有不同的意义,在多线程的环境下,"同步"的意义就是互斥,即一个在进行时,另一个无法插入.

我们称synchronized为对象的synchronized,某个线程执行到一个对象的synchronized时,另一个线程执行到同一个对象的synchronized就会阻塞等待.

java的 锁 是存在在对象头里的
在这里插入图片描述

针对每一把锁,操作系统内部都维护了一个等待队列,当某个锁被一个线程占有时,其他的线程想要进行加锁操作就加不上了,从而进入了阻塞等待的状态,一直到之前被锁住的线程执行完后,操作系统在调度其他等待锁的线程
在这里插入图片描述
synchronized是 可重入锁 的,即当同一个线程对同一个锁对象进行二次执行,是可以允许完成的.
如下图,两个increase都是对 this 对象加锁的

class Counter1{
    public volatile static int counter;

    public synchronized void increase1(){
        counter++;
    }
    public synchronized void increase2(){
        counter++;
    }
}
public class Demo26 {
    public static Counter1 counter = new Counter1();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() ->{
            counter.increase1();
            counter.increase2();
        });

        t1.start();
        t1.join();
        System.out.println(counter.counter);
    }

}

synchronized 使用示例

  1. synchronized直接修饰普通方法 锁的是synchronized对象
public class SynchronizedDemo {
  public synchronized void methond() {
 }
}
  1. synchronized修饰类方法 锁的是synchronized的类对象
public class SynchronizedDemo {
  public synchronized static void method() {
 }
}
  1. 修饰代码块: 需要明确指定锁哪个对象
    锁当前对象:
public class SynchronizedDemo {
  public void method() {
    synchronized (this) {
     
   }
 }
}

锁类对象

public class SynchronizedDemo {
  public void method() {
    synchronized (SynchronizedDemo.class) {
   }
 }
}

两个线程竞争竞争同一把锁才会产生竞争,两个线程分别尝试获取不同的锁不会产生竞争.

内存可见性导致的线程不安全

可见性指, 一个线程对共享变量值的修改，能够及时地被其他线程看到.

  1. 当线程要读取一个共享变量的时候, 会先把变量从内存拷贝到cpu的寄存器中, 再从寄存器读取数据.
  2. 当线程要修改一个共享变量的时候, 也会先修改寄存器中的副本, 再同步回内存

由于每个线程有自己的cpu寄存器位置, 这些寄存器中的内容相当于同一个共享变量的 “副本”. 此时修改线程1的寄存器中的值, 线程2 的寄存器不一定会及时变化.

  1. 初始情况下, 两个线程的工作内存内容一致.
  2. 一旦线程1 修改了 a 的值, 此时内存不一定能及时同步. 对应的线程2 寄存器中的 a 的值也不一定能及时同步.
static class Counter{
        public int flag = 0;
    }

    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread t1 = new Thread(() ->{
            while(counter.flag == 0){

            }
            System.out.println("循环结束");
        });


        Thread t2 = new Thread(() ->{
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入flag的值");
            counter.flag = scanner.nextInt();
        });
        t1.start();

        t2.start();
    }

当flag的值修改后,循环并没有立刻退出
在这里插入图片描述
但是,在加入volatile后.就可以保证内存可见性
在这里插入图片描述

在这里插入图片描述
但是使用 synchronized 关键字加锁。不光保证原子性，还能保证内存可见性。被 synchronized 包裹起来的代码，编译器就不敢轻易的做出上面优化的那种操作。

wait 和 notify

wait和notify分别指阻塞和通知停止阻塞,更倾向于处理线程调度随机性的问题.
wait必须在加锁的代码块中使用,
wait 内部会做三件事：1、先释放锁 2、等待其他线程的通知 3、收到通知之后，重新获取锁，并继续往下执行。

public static void main1(String[] args) throws InterruptedException {
    Object object = new Object();
    //wait 哪个对象，就得针对哪个对象加锁。
    synchronized (object) {
        System.out.println("wait 前");
        object.wait();
        System.out.println("wait 后");
    }
}

在这里插入图片描述

public static Object locker = new Object();
    public static void main(String[] args) {
        Thread waitTask = new Thread(() ->{
            synchronized (locker){
                try{
                    System.out.println("wait 开始");
                    locker.wait();
                    System.out.println("wait 结束");

                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        });

        waitTask.start();

        Thread notifyTask = new Thread(() ->{
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入任意内容");
            scanner.next();

            synchronized (locker){
                System.out.println("notify 开始");
                locker.notify();
                System.out.println("notify 结束");
            }
        });
        notifyTask.start();
    }

在这里插入图片描述

notifyAll

假如一个锁对象有10个阻塞的线程,notify只会随机唤醒一个线程,而notifyAll则会唤醒所有阻塞的线程,但是仍处于随即调度状态.

心有猛虎嗅蔷薇
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程三大特性——可见性
城南孔乙己的专栏
12-22 3086
JMM 可见性问题 在多线程应用程序中，线程对非易失性变量（non-volatile variables）进行操作，出于性能原因，每个线程在处理变量时会将变量从主内存复制到CPU缓存中。如果您的计算机包含多个CPU，每个线程可能运行在不同的CPU上。这意味着，每个线程可以将变量复制到不同CPU的CPU缓存中。 假设两个或多个线程访问一个共享对象，该对象包含如下声明的计数器变量： public class SharedObject { public int counter .
Java多线程之线程的可见性(二)
heihei
11-28 1619
1.Java的内存模型Java Memory Model (JAVA 内存模型）描述线程之间如何通过内存(memory)来进行交互。 具体说来， JVM中存在一个主存区（Main Memory或Java Heap Memory），对于所有线程进行共享，而每个线程又有自己的工作内存（Working Memory），工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作并非发生在主存区，而是发生在
java多线程的可见性
AQ_xiaobin的博客
12-30 361
1.可见性 ： 一个线程对共享变量值的修改，能过及时地被其他线程看到。 2.共享变量 ： 如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。 3.java内存模型 : 描述了java程序中各种变量（共享变量）的访问规则，以及在JVM中将变量存储到内存和从内存中读取出变量这样的底层细节。     所有变量都存储在主内存中，   每个线程都有自己独立的工作内存
java多线程可见性
咏樟的博客
07-30 527
java多线程可见性1、可见性介绍1.1、可见性1.2、java内存模型JMM1.3、两条规定1.4、共享变量可见性实现的原理2、synchronized实现可见性2.1、JMM关于synchronized的两条规定2.2、线程执行互斥代码的过程2.3、了解重排序和as-if-serial2.4、可见性分析3、volatile实现可见性4、synchronized和volatile比较 1、可见性介绍 1.1、可见性 1.2、java内存模型JMM **java内存模型（ Java Memory Mode
java多线程开发的可见性问题
天外水火的专栏
08-06 817
java多线程开发可见性问题在于多线程之间使用共享的变量，如果其他线程也在修改变量，因为执行顺序问题，在当前线程中不一定会得到真实的值，比如下面的代码，看看是否达到了可以修改共享变量，并且在线程中成功应用。 package test.commontest; public class TestThread { //共享变量flag public static Boolean ...
多线程之可见性：volatile
striveb的博客
10-30 2095
一.什么是volatile,它的作用是什么 我们知道线程安全的三大核心就是原子性、可见性和顺序性，synchronized可以实现原子性，而volatile就是来实现可见性。 那么什么是可见性呢？ 我们知道，在现代计算机中，由于 CPU 直接从主内存中读取数据的效率不高，所以都会对应的 CPU 高速缓存，先将主内存中的数据读取到缓存中，线程修改数据之后首先更新到缓存，之后才会更新到主内存。如...
了解Java多线程的可见性与有序性
08-25
- **线程终止规则**：子线程终止前的对共享变量的修改在线程终止后对其他线程可见。 - **线程中断规则**：中断线程的interrupt()操作先于被中断线程检查到中断状态。 理解并熟练掌握Java多线程的可见性和有序性，...
java多线程——线程之间的可见性
guduyishuai的博客
09-19 2527
目录 一、简介 二、volatile 三、synchronized 四、不会从主内存拉取的操作 五、从主内存中拉取的操作 一、简介        我们知道线程在工作的时候有自己的私有内存，工作内存。程序运行的时候从主内存拉取需要的变量到工作内存，处理完再返回主内存。这篇文章总结哪些代码会使线程去主内存拉取变量。 二、volatile        volatile修饰的变量，不论...
Java多线程可见性（一）
沐沐的博客
12-05 1092
一：内存可见性 线程对共享变量的修改，可以及时的被其他线程看到。 那何为共享变量呢？就是在多个线程的工作内存中存在 如下图所示：所谓的共享变量就是主内存中名为S的变量，程序中所有的变量都会存储在主内存中；其他线程也会有自己的工作内存，此工作内存的作用是为线程与主内存之间建立桥梁 由此图总结如下： 1：其他线程不可以直接访问主内存中的变量，必须先与自己的工作内存进行交互再由工作内存与主内
java多线程进阶（三）可见性
jiayibingdong的博客
05-09 1505
执行程序，会发现程序无法自动结束，因为修改的stop值无法被线程thread感知到，这就是不同线程共享变量的可见性问题。
线程同步，多个线程操作同一个资源；关键词：synchronized、死锁、Lock
weixin_45913226的博客
05-06 1614
1、并发 并发：同一个对象被多个线程同时操作 2、线程同步 处理多线程问题时，多个线程访问同一个对象，又可能会出错，所以我们需要让这些线程排对等候，一个一个访问这些对象。线程同步就是一种等待机制，多个需要访问这个对象的线程进入这个对象的等待池 形成队列，等前面的线程使用完毕，下一个线程在使用。 3、队列和锁 遇到的问题： 1、一个线程持有了这个对象的锁，会使其他所有需要此锁的线程挂起。 2、在多线程竞争下，拿锁，释放锁会导致较多的上下文切换和调度时延，引起性能问题 3、如果一个优先级高的线程等待一个优先级
多线程中的可见性问题
chenchaozzu的博客
08-16 3939
1.缓存导致的可见性问题 可见性问题是指一个线程修改了某一个共享变量的值时，其他线程是否能够立即知道这个修改。 对于串行程序来说，可见性问题是不存在的，因为你在任何一个操作步骤中修改了某个变量，在后续的步骤中读取这个变量的值时，读取的一定是修改后的新值。 在并行程序中，如果一个线程修改了某一个全局变量，那么其他线程未必可以马上知道这个改动。多核时代，每颗 CPU 都有自己的缓存，这时 CPU 缓存与内存的数据一致性就没那么容易解决了，一个CPU缓存中的变量对另外一个CPU是不可见的 如上图中，两个线程在
多线程之内存可见性Volatile（一）
努力+坚持，而且还很年轻
03-15 6676
从这篇博文开始，我们开始分享一些多线程的内容，毕竟在工作中，使用多线程比较多。多总结一下，终归没有坏处。这个系列的文章不会特别长，争取在3到5分钟之间结束，主要以说明白内容，给出相应的解决方案，重点在于实践。如标题所示，这篇博文我们简单的介绍一下内存可见性问题，之前，要简单的介绍一下什么是内存模型？内存模型什么是JAVA 内存模型？Java Memory Model (JAVA 内存模型）是描述线程
多线程安全
飞上云端看彩虹
05-11 317
什么是线程安全？ 为什么有线程安全问题？ 当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。 线程安全解决办法: 问:如何解决多线程之间线程安全问题? 答:使用多线程之间同步synchronized或使用锁(lock)。 问:为什么使用线程同步或使用锁能解决线程安全问题呢？ 答:将可能会发生数据...
java多线程-线程之间的可见性
makeliwei1的博客
07-07 2224
java多线程-可见性 (1)定义：一个线程对主内存的修改可以及时的被其他线程观察到 (2)共享变量在线程间不可见的原因： ①　线程交叉执行 ②　线程交叉执行结合指令重排序 ③　共享变量没有在更新后的值没有在工作内存与主存之间及时更新 (3)synchronized的两条规定 ①　线程释放锁前，必须把共享变量的最新值刷新到主内存当中 ②　线程获取锁时，将当前线程的本地内存置为无效，...
Spring的JPA事务管理
乌鲁木齐001号程序员
06-28 273
Demo1 - 代码实现 - PROPAGATION_REQUIRED web层调service的方法没有加事务，service中的事务传播机制为PROPAGATION_REQUIRED，故service中的方法受事务控制，数据保存失败； PROPAGATION_REQUIRED A有，B不新建事务 A没有，B新建事务 package com....
多线程事务控制
青青河边草
11-26 5585
多线程事务控制 spring无法对多线程进行事务控制，原因是： 多线程底层连接数据库的时候，是使用的线程变量（TheadLocal）,所以，开多少线程理论上就会建立多少个连接，每个线程有自己的连接，事务肯定不是同一个了。 解决办法：我强制手动把每个线程的事务状态放到一个同步集合里面。然后如果有单个异常，循环回滚每个线程。 假如service中的一个方法由以下逻辑构成： 1.前面的是调用多线程前的操作 2.调用多线程的操作 假设其中任何一个与数据库的更新操作发生了异常，想要整体回滚怎么办？那么就要
深入理解Java volatile：多线程可见性背后的原理
Java中的volatile关键字在多线程编程中扮演着重要角色，它确保了变量的可见性和避免了因缓存一致性问题导致的意外行为。本文将带你理解volatile的关键作用以及其实现原理。 首先，我们来探讨volatile的作用。在多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值