JAVASE(21）等待唤醒机制、悲乐观锁的内存可见性问题、线程池、定时器和设计模式

最新推荐文章于 2020-03-10 11:45:43 发布
最新推荐文章于 2020-03-10 11:45:43 发布
阅读量204 收藏
点赞数
分类专栏： 后端学习:JAVASE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gexin0517/article/details/97811604
版权

文章目录

等待唤醒机制：

不同种类的线程之间的通信问题

  • 生产线程：生产出了资源，需要通知消费线程来消费
  • 消费线程：消费了资源，等待生产线程来生产

线程的随机性导致数据安全性问题

线程等待唤醒机制：
  • 作为生产线程来说，生产资源，通知消费线程来消费，等待消费线程来消费。
  • 作为消费线程来说，消费线程，通知生产喜爱能撑来生产。
  • 通过线程的
使用的方法：

void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 wait（）方法一但等待，就必须释放锁。唤醒之后多次线程还会再次争抢时间片。从哪里等待，被唤醒后还会在此处醒来。

void wait(long timeout) 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
void wait(long timeout, int nanos) 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。

void notify() 唤醒在此对象监视器上等待的单个线程。
void notifyAll() 唤醒在此对象监视器上等待的所有线程。

面试题：

sleep方法和wait方法的区别：

共同点：可以使线程都处于阻塞状态

不同点：

  1. sleep必须设置时间量，wait可以设置时间量也可以不同设置。
  2. sleep方法在线程阻塞后，不释放锁。wait方法等待后会立即释放锁。

代码展示：

public class MyTest{
    public static void main(String[] args) {
       //线程的之间的等待唤醒机制，也就是生长者消费者模式
        //1.定义一个资源
        //2.要有一个生产线程
        //3.要有一个消费线程
        //4.测试类
        Student student = new Student();
        SetThread th1 = new SetThread(student);
        GetThread th2 = new GetThread(student);
        th1.start();
        th2.start();
    }
}

public class Student {
    public String name;
    public int age;
    public boolean flag = false;
    //这个标记的意思是，代表有没有资源
    // false代表没有资源，true 代表有资源
}

public class SetThread extends Thread {
    Student student;
    int i = 0;
    public SetThread(Student student) {
        this.student = student;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (student) {
                //作为生产者来说：有了资源，等着，通知消费线程来消费
                if (student.flag) {
                    try {
                        student.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (i % 2 == 0) {
                    student.name = "张三";
                    student.age = 23;
                    //等待...
                } else {
                    student.name = "李四";
                    student.age = 24;
                }
                //通知消费线程，去消费
                student.flag = true; //修改标记
                student.notify();//唤醒等待的线程，唤醒之后，多个线程还要再次争抢时间片
                i++;
            }
        }
    }
}

public class GetThread extends Thread {
    Student student;
    public GetThread(Student student) {
        this.student = student;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (student) {

                if (!student.flag) {
                    try {
                        student.wait();
                        //没有资源等待,wait()方法一旦等待，
                        // 就必须释放锁，从哪里等待，被唤醒后，就从这里醒来
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //消费了资源，通知生产线程去生产
                System.out.println(student.name + "===" + student.age);
                student.flag = false;
                student.notify();
                //唤醒等待的 线程
            }
        }
    }
}

内存可见性问题：

一、 volatile 解决内存可见性问题

1.Java内存模型

想要理解volatile为什么能确保可见性，就要先理解Java中的内存模型是什么样的。

Java内存模型规定了所有的变量都存储在主内存中。每条线程中还有自己的工作内存，线程的工作内存中保存了被该线程所使用到的变量（这些变量是从主内存中拷贝而来）。线程对变量的所有操作（读取，赋值）都必须在工作内存中进行。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。

2.Java中的可见性

对于可见性，Java提供了volatile关键字来保证可见性。
当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见。

注意：

  • volatile 不具备“互斥性”
  • volatile 不能保证变量的“原子性”（数据的重复出现，刷新太慢）

代码显示：

public class TestVolatile {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();
        while (true) {
            if (td.isFlag()) {
                System.out.println("------------------");
                break;
            }
        }
    }
}

class ThreadDemo implements Runnable {
    volatile private boolean flag = false;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        flag = true;
        System.out.println("flag=" + isFlag());
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
二、CAS算法

CAS算法：比较并交换，是一种硬件支持，比使用synchronized加锁的方式，更加的减少资源的使用.
下面的链接时关于CAS算法的详细的说明。
https://www.jianshu.com/p/21be831e851e

悲观锁和乐观锁

synchronized悲观锁，存在互斥性

volatile和CAS算法都是乐观锁，不存在互斥性

线程的几种状态

  1. 新建状态：线程被创建出来
  2. 就绪状态：抢夺时间片中
  3. 运行状态：抢夺到CPU运行权
  4. 阻塞状态：抢夺到CPU运行权，但不能执行
  5. 死亡状态

[外链图片转存失败(img-Nq1FVaPH-1564485057675)(C:\Users\Administrator\Desktop\线程的运行状态图.jpg)]

采用匿名内部类开启线程

方式1：
public class Demo {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                System.out.println("方法1执行了");
            }
        }.start();
    }
}
方式2：
public class Demo {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("方式2执行了");
            }
        }) {
        }.start();
    }
}

线程池

概念：

是一个容器，装有线程对象的容器

为什么要线程池？

在这里插入图片描述

虽然线程是个轻量级的东西， 但是对于互联网应用来说，如果每个用户的请求都创建一个线程，那会非常得多，服务器也是难于承受，再说了，众多的线程去竞争CPU，不断切换，也会让CPU调度不堪重负，很多线程将不得不等待。所以前辈们的思路就是（1）用少量的线程 （2） 让线程保持忙碌，就是说只创建一定数量的线程，让这些线程去处理所有的任务，任务执行完了以后，线程并不结束，而是回到线程池中去，等待接受下一个任务。

jdk5开始新新增了一个executors工厂类来产生线程池，有如下方法：

  1. public static ExecutorService newCachedThreadPool():根据任务的数量来创建线程对应的线程个数
  2. public static ExecutorService newFixedThreadPool(int nThreads):固定初始化几个线程
  3. public static ExecutorService newSingleThreadExecutor():初始化一个线程的线程池
  • 使用runnable的方法
    创建线程池对象
    创建Runnable实例
    提交Runnable实例 submit方法
    关闭线程池

代码实现：

public class Myrunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("这个线程执行了");
    }
}
public class Demo {
    public static void main(String[] args) {
        Myrunnable myrunnable = new Myrunnable();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(myrunnable);
    }
}

  • 使用callable的方法（可以获取返回值）

    ​ 创建线程池对象
    ​ 创建Callable实例
    ​ 提交Callable实例 submit方法
    ​ 关闭线程池

代码实现

public class Mycallable implements Callable {
    String s="你好";
    @Override
    public Object call() throws Exception {
        System.out.println("这是一个线程");
        return s;
    }
}
public class Demo {
    public static void main(String[] args) {
        Mycallable mycallable = new Mycallable();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(mycallable);
    }
}

定时器

概述

定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。

Timer和TimerTask

public void schedule(TimerTask task, long delay)延长多长时间后执行

public void schedule(TimerTask task,long delay,long period);往后延长多长时间后间隔period时长重复执行
public void schedule(TimerTask task, Date time)；延长到日期后执行

public void schedule(TimerTask task, Date firstTime, long period):延长到日期后执行间隔period时长重复执行

public abstract void run()
public boolean cancel()取消执行任务

案例演示：

public class Mytimertask1 extends TimerTask {
    Timer timer;
    public Mytimertask1(Timer timer) {
        this.timer = timer;
    }
    @Override
    public void run() {
        System.out.println("这条语句执行了");
        timer.cancel();
    }
}
public class Test {
    public static void main(String[] args) throws ParseException {
        Timer timer = new Timer();
        String str="2019-07-30 14:56:00";
        Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(str);
        Mytimertask1 mytimertask1 = new Mytimertask1(timer);
        timer.schedule(mytimertask1,date);
    }
}

设计模式：

单例设计模式
  1. 饿汉式：
    public class Student {
    //饿汉式
    private static Student student=new Student();
    //创建一个静态的对象，静态的对象只能调用一次
    private Student(){};
    //私有化无参构造
    public static Student getStudent(){
        //创建一个静态的方法
        return student;
    }
}
public class TEst {
    public static void main(String[] args) {
        Student student = Student.getStudent();
    }
}

  2. 懒汉式

public class Teacher {
         //懒汉式   
    private Teacher teacher=null;
    private Teacher() {};
        //私有化无参构造
    public synchronized Teacher getTeacher(){
        //乐观锁可以防止多线程产生的问题
        if (teacher==null){
            Teacher teacher = new Teacher();
        }
        return teacher;
    }
}
GEX0o0
关注
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
Java 同步相关概念（synchronized、volatile）(悲观锁、乐观锁)（可见性、原子性和有序性）
“点点”专栏
02-20 661
锁的目的让一系列操作能被当作“原子”，能够正确执行。锁分为悲观锁和乐观锁，悲观锁就是假设一个线程在执行某些操作时（比如读写数据）别的线程也一定会一定会执行这些操作，叫并发冲突，所以在执行前先上锁，只能当前线程先操作，别的线程要操作时发现有锁先阻塞。乐观锁就是，假设不会有并发冲突，线程该执行什么操作就执行什么操作，只有更新的时候，才会检查有没有冲突，如果有冲突，可以让用户决定怎么处理，或者重试。乐观...
JavaSE回顾(三)：方法的基本用法以及重载和递归
A_K_L的博客
03-10 343
一、方法的基本用法 方法就是指将一段代码封装在一个结构体之中，实现某种功能，可以被重复调用的代码块。 方法的意义 模块化的组织代码，使程序变得更简短而清晰。 有利于程序维护。 可以提高程序开发的效率。 提高了代码的重用性。 基本语法 // 方法定义 public static 方法返回值 方法名称（[参数类型 形参 ...]){ 方法体代码; [return 返回值]; } /...
Java - JavaSE - 多线程
ChenBin113
01-02 228
多线程 多线程创建的三种方式： 继承 Thread 类，重写 run 方法。 实现 Runnable 接口。 实现 Callable 接口。这个方法比较编写代码比较复杂，是 JDK 1.5 出来的。 方式 1 和 方式 2 的区别： extends 是继承，一般要增强类的功能使用，重写或添加方法。 implements 是实现接口。 单继承和多实现。 Thread 类源码分析 从官方文档得...
JavaSE阶段1_类
Gaos的BLOG
07-05 386
符 class 类名｛ //一个类中可以有多个类，但是只有一个public修饰的，而且与文件名相同 1.属性：变量 局部变量：在方法中定义变量 全局变量：类变量（static修饰）（是所有对象共有的，如果一个改变，其它对象使用也是改变的） 成员变量：非静态方法（对象私有的） 2.方法： main方法 普通方法
SEAndroid 介绍及其基本实现原理
万能的终端和网络
05-08 1947
SEAndroid（Security-Enhanced Android），是将原本运用在Linux操作系统上的MAC强制存取控管套件SELinux，移植到Android平台上。可以用来强化Android操作系统对App的存取控管，建立类似沙箱的执行隔离效果，来确保每一个App之间的独立运作，也因此可以阻止恶意App对系统或其它应用程序的攻击。 SEAndroid的中心理念是，即使root权限被篡
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
基于JavaSE的ColthesSupermarketSystem设计源码
09-30
该项目是一款基于JavaSE开发的实战级衣服超市系统源码，共包含96个文件，涵盖27个Java类文件、15个XML配置文件、10个JAR库文件、4个属性文件、3个编译后的OBJ文件、2个Markdown文件、2个Manifest文件、2个批处理文件...
基于JavaSE实践的五子棋和中国象棋游戏设计源码
10-02
该项目是一款结合JavaSE技术实现的五子棋和中国象棋游戏设计源码，共包含23个文件，涵盖6个XML配置文件、6个Java源代码文件、4个PNG图像文件、3个Markdown文档文件，以及必要的Git忽略和Idea项目文件。游戏功能包括...
基于JavaSE的Java编程案例设计源码
最新发布
10-03
该仓库提供了一个基于JavaSE的Java编程案例设计源码集，包含73个文件，涵盖了41个Java源文件、14个JAR包、8个XML配置文件、4个Markdown文档、1个Git忽略规则以及其他相关文件。这些资源旨在辅助Java编程的学习与实践...
基于JavaSE的日常Java编程设计源码
10-02
该项目为日常Java编程设计源码，主要采用JavaSE开发，包含67个文件，其中Java源文件45个，类文件14个，XML文件4个，Idea项目文件3个，Git忽略文件1个，内容丰富，适合作为学习与参考。
什么是高并发；超发的解决思路（悲观锁与乐观锁）；高并发与多线程的关系--持续更新
zsvole的博客
01-18 2万+
关键词： 线程，同步，单例，高并发，高访问，死锁 一、大规模并发带来的挑战 在过去的工作中，我曾经面对过5w每秒的高并发秒杀功能，在这个过程中，整个Web系统遇到了很多的问题和挑战。如果Web系统不做针对性的优化，会轻而易举地陷入到异常状态。我们现在一起来讨论下，优化的思路和方法哈。 1. 请求接口的合理设计 一个秒杀或者抢购页面，通常分为2个部分，一个是静态的H
Java实现内存可见性的两种方法比较：synchronized 和 Volatile以及涉及到锁的剖析
chajinglong的专栏
12-22 1810
这篇文中讲述了通过synchronized和 volatile 变量实现内存可见性的方法，这里比较下二者的区别。* volatile 变量是一种稍弱的同步机制在访问 volatile 变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此 volatile 变量是一种比 synchronized 关键字更轻量级的同步机制。 * 从内存可见性的角度看，写入 volatile 变量相当于退出同步代码块
javase格式化数字实例总结
meifage的专栏
12-11 521
1、去掉数字前面多余的0与小数点后多余的0 例如00000123 结果  123 例如123.1000 结果123.1 解决 1）String str = "00000123.100"; System.out.println(Double.parseDouble(str)); 结果：123.1 2）String str = "00000123.100"; Sys
JAVASE(20)多线程
keep hungry keep foolish
07-27 288
1.多线程程序实现 多线程程序实现的方式1 public class MyThread extends Thread{ @Override //继承Thread类 //重写run( )方法 public void run() { for (int i = 0; i < 10; i++) { System.out.pri...
JAVASE(1)Java相关知识、运算符
keep hungry keep foolish
06-01 256
JAVA 的基础知识 ——————————————————————————————— 1.Java语言平台版本 J2SE(Java 2 Platform Standard Edition)标准版 是为开发普通桌面和商务应用程序提供的解决方案该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发 J2ME(Java 2 Platform Micro Edition)小型版 是为开发电子消费产品和...
JAVA1.5和1.7的新特性
keep hungry keep foolish
08-04 208
文章目录JDK5新特性新特性包括：枚举（enum）1.枚举概述:2.实现枚举类3.通过enum实现枚举类4.枚举的注意事项JDK7新特性1.二进制字面量2.数字字面量3.switch 语句可以用字符串4.泛型简化 JDK5新特性 新特性包括： 自动拆装箱、泛型、增强for、可变参数和枚举 枚举（enum） 1.枚举概述: 是一个类只能存在几个固定的对象,那么这个就是枚举.我们就可以使用这些对象可以...
JAVASE(19)NIO、内存映射
keep hungry keep foolish
07-27 208
Java NIO 简介 Java NIO 与 IO 的主要区别 缓冲区 (Buffer) 和通道 (Channel) 文件通道 (FileChannel) NIO 的非阻塞式网络通信 选择器 (Selector) SocketChannel , ServerSocketChannel, DatagramChannel 管道 (Pipe) Java NIO2(Path、Paths与Files...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值