首页 > 编程语言 >Java之线程篇四

Java之线程篇四

时间:2024-09-18 12:23:44浏览次数:11  
标签:Java Thread System 线程 new public wait

目录

volatile关键字

volatile保证内存可见性

代码示例

代码示例2-(+volatile)

volatile不保证原子性

synchronized保证内存可见性

wait()和notify()

wait()方法

notify()

理解notify()和notifyAll()

wait和sleep的对比


volatile关键字
volatile保证内存可见性

volatile 修饰的变量, 能够保证 "内存可见性".

代码在写入 volatile 修饰的变量的时候:

改变线程工作内存中volatile变量副本的值
将改变后的副本的值从工作内存刷新到主内存

代码在读取 volatile 修饰的变量的时候: 

从主内存中读取volatile变量的最新值到线程的工作内存中
从工作内存中读取volatile变量的副本 

加上 volatile , 强制读写内存. 速度是慢了, 但是数据变的更准确了。 

代码示例
public class Demo13 {
    private static int isQuit=0;

    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            while(isQuit==0){
            }
            System.out.println("t1 退出");
        });
        t1.start();

        Thread t2=new Thread(()->{
            System.out.println("请输入 isQuit:");
            Scanner scanner=new Scanner(System.in);
            isQuit=scanner.nextInt();
        });
        t2.start();
    }
}

运行结果

通过jconsole观察,会看到线程t1处于RUNNABLE状态。

t1 读的是自己工作内存中的内容 . 当 t2 对 flag 变量进行修改 , 此时 t1 感知不到 flag 的变化 .

原因解释:

1) load 读取内存中isQuit的值到寄存器中.
2)通过cmp 指令比较寄存器的值是否是0.决定是否要继续循环.
由于这个循环,循环速度飞快.短时间内,就会进行大量的循环.也就是进行大量的load和cmp 操作.此时,编译器/JVM就发现了,虽然进行了这么多次load,但是 load 出来的结果都一样的.并且, load 操作又非常费时间,一次load花的时间相当于上万次cmp 了.
所以编译器就做了一个大胆的决定~~只是第一次循环的时候才读了内存.后续都不再读内存了,而是直接从寄存器中,取出isQuit的值了. 

代码示例2-(+volatile)
public class Demo13 {
    private static volatile int isQuit=0;

    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            while(isQuit==0){
            }
            System.out.println("t1 退出");
        });
        t1.start();

        Thread t2=new Thread(()->{
            System.out.println("请输入 isQuit:");
            Scanner scanner=new Scanner(System.in);
            isQuit=scanner.nextInt();
        });
        t2.start();
    }
}

运行结果

代码示例3-(+sleep)

public class Demo13 {
    private static int isQuit=0;

    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            while(isQuit==0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("t1 退出");
        });
        t1.start();

        Thread t2=new Thread(()->{
            System.out.println("请输入 isQuit:");
            Scanner scanner=new Scanner(System.in);
            isQuit=scanner.nextInt();
        });
        t2.start();
    }
}

运行结果

volatile不保证原子性

代码示例

class Counter {
    volatile public int count = 0;
    void increase() {
            count++;
    }
}

public class Demo13 {
    public static void main(String[] args) throws InterruptedException {
        final Counter counter = new Counter();
        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(counter.count);
    }
}

运行结果

我们会发现,加上volatile以后,依旧不是线程安全的。

synchronized保证内存可见性

代码示例

class Counter {
    public int flag = 0;
}

public class Demo13 {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            while (true) {
                synchronized (counter) {
                    if (counter.flag != 0) {
                        break;
                    }
                }
            }
            System.out.println("循环结束!");
        });
        Thread t2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入一个整数:");
            counter.flag = scanner.nextInt();
        });
        t1.start();
        t2.start();
    }
}

运行结果

wait()和notify()
wait()方法

wait 做的事情:

使当前执行代码的线程进行等待. (把线程放到等待队列中)
释放当前的锁
满足一定条件时被唤醒, 重新尝试获取这个锁. 

wait 要搭配 synchronized 来使用. 脱离 synchronized 使用 wait 会直接抛出异常.

代码示例

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();

        synchronized (object) {
            System.out.println("wait 之前");
            // 把 wait 要放到 synchronized 里面来调用. 保证确实是拿到锁了的.
            object.wait();
            System.out.println("wait 之后");
        }
    }
}

 运行结果

此时object就会一直进行wait,当然我们肯定不想让程序一直等待下去,下面将介绍notify()来唤醒它。

notify()

notify 方法是唤醒等待的线程. 

方法notify()也要在同步方法或同步块中调用,该方法是用来通知那些可能等待该对象的对象锁的其它线程,对其发出通知notify,并使它们重新获取该对象的对象锁。
如果有多个线程等待,则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 "先来后到"),在notify()方法后,当前线程不会马上释放该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出同步代码块之后才会释放对象锁。

代码示例

public class Demo15 {
    public static void main(String[] args) {
        Object object = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (object) {
                System.out.println("wait 之前");
                try {
                    object.wait();
//                    object.wait(5000);//也可以指定等待时间后自动唤醒
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("wait 之后");
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (object) {
                System.out.println("进行通知");
                object.notify();
            }
        });

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

运行结果

notifyAll()
notify方法只是唤醒某一个等待线程. 使用notifyAll方法可以一次唤醒所有的等待线程. 代码示例
class WaitTask implements Runnable {
    private Object locker;
    public WaitTask(Object locker) {
        this.locker = locker;
    }
    @Override
    public void run() {
        synchronized (locker) {
            while (true) {
                try {
                    System.out.println("wait 开始");
                    locker.wait();
                    System.out.println("wait 结束");
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
            }
        }
    }
}
class NotifyTask implements Runnable {
        private Object locker;
        public NotifyTask(Object locker) {
            this.locker = locker;
        }
        @Override
        public void run() {
            synchronized (locker) {
                System.out.println("notify 开始");
                locker.notifyAll();
                System.out.println("notify 结束");
            }
        }
}

public class Demo16 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(new WaitTask(locker));
        Thread t3 = new Thread(new WaitTask(locker));
        Thread t4 = new Thread(new WaitTask(locker));
        Thread t2 = new Thread(new NotifyTask(locker));
        t1.start();
        t2.start();
        t3.start();
        Thread.sleep(5000);
        t4.start();
    }
}

运行结果

注意: 虽然是同时唤醒 3 个线程, 但是这 3 个线程需要竞争锁. 所以并不是同时执行, 而仍然是有先有后的执行.

理解notify()和notifyAll()
notify 只唤醒等待队列中的一个线程 . 其他线程还是乖乖等着.

notifyAll 一下全都唤醒, 需要这些线程重新竞争锁.

wait和sleep的对比
唯一的相同点就是都可以让线程放弃执行一段时间.
1. wait 需要搭配 synchronized 使用 . sleep 不需要 . 2. wait 是 Object 的方法 sleep 是 Thread 的静态方法 .

标签:Java,Thread,System,线程,new,public,wait
From: https://blog.csdn.net/wmh_1234567/article/details/140991449

相关文章

  • Java.lang.CloneNotSupportedException 不支持克隆异常
    java.lang.CloneNotSupportedException是Java中表示一个对象无法被克隆的异常。在Java中,对象的克隆是通过实现Cloneable接口和重写Object类中的clone()方法来完成的。如果一个类没有实现Cloneable接口,并且尝试调用其clone()方法,那么就会抛出CloneNotSupportedExcep......
  • Java调用Apache commons-text求解字符串相似性
    前言    在之前的一篇漂亮国的全球的基地博客中,我们曾经对漂亮国的全球基地进行了一些梳理。博文中使用的数据来源,重点是参考以为博主分享的KML的数据,同时针对其国内的基地部署信息,我们从互联网百科的数据中搜寻到一些。其实拿到这两份数据的时候,是存在一些问题的,比如,KML的......
  • 【编程底层原理】Java执行CAS后底层由谁执行cmpxchg指令?CPU?是否会导致从用户态切换
    Java中的CAS操作是由Java虚拟机(JVM)提供的原子类实现的,这些原子类利用了底层硬件的CAS指令,比如x86架构中的cmpxchg指令。以下是这个过程的一些关键点:原子类封装:Java的java.util.concurrent.atomic包提供了一系列的原子类,如AtomicInteger、AtomicLong等,它们封装了CAS操作,使得......
  • 第八章,多线程
    高级编程文章目录高级编程第八章,多线程一,多线程二,主线程三,线程的创建和启动四,线程的状态五,同步方法六,线程安全的类型七,常见类型对比第八章,多线程一,多线程什么是多线程如果在一个进程中同时运行了多个线程,用来完成不同的工作,则称之为“多线程”多个线程交替占......
  • Java客户端SpringDataRedis(RedisTemplate使用)
    文章目录⛄概述⛄快速入门❄️❄️导入依赖❄️❄️配置文件❄️❄️测试代码⛄数据化序列器⛄StringRedisTemplate⛄RedisTemplate的两种序列化实践方案总结⛄概述SpringData是Spring中数据操作的模块,包含对各种数据库的集成,其中对Redis的集成模块就叫做SpringDataRedis,......
  • springboot整合mybatis(使用druid线程池)
    pom引入<mybatis.version>2.3.2</mybatis.version> <druid.version>1.1.23</druid.version><!--数据库--><dependency><groupId>org.mybatis.spring.boot</groupId><art......
  • java获取object中的value
    在Java中,获取对象(Object)中的值通常取决于对象的类型以及它的结构。Java是一种面向对象的编程语言,对象可以包含不同类型的数据,包括基本数据类型(如int,double等)的包装类、其他对象以及数组等。下面列出了一些常见的方法来获取对象中的值:1.直接访问(针对基本数据类型和包装类)如果你的......
  • 大学生网页制作期末作业——html+css+javascript+jquery旅游官网6页 html大学生网站开
    ......
  • 基于Java的面向社区的智能化健康管理系统设计与实现
    文章目录1.前言2.详细视频演示3.论文参考4.项目运行截图5.技术框架5.1后端采用SpringBoot框架5.2前端框架Vue6.可行性分析7.系统测试7.1系统测试的目的7.2系统功能测试8.数据库表设计9.代码参考10.数据库脚本11.作者推荐项目12.为什么选择我?13.获取源......
  • 【Java】若依(ruoyi)——7.代码生成(二)细节操作
    之前我们已经学习了代码生成的基础使用:https://www.cnblogs.com/luyj00436/p/18398248。即创建数据库并根据三种数据结构生成代码。1.基本信息和生成信息 前缀可以在配置表设置默认配置。单应用在resources目录下的application.yml,多模块ruoyi-generator中的resources目录下......