当前位置： 首页 > article >正文

Java线程池和原子性

article 2024/9/27 5:17:47

文章目录

  • 前言
  • 1 线程池
    • 1.1 线程池概述
      • 1.1.1 线程池存在的意义
      • 1.1.2 Executors默认线程池
    • 1.2 线程状态介绍
      • 1.2.1 线程状态源码
      • 1.2.2 线程状态含义
      • 1.2.3 线程状态转换图
  • 2 原子性
    • 2.1 volatile关键字
    • 2.2 synchronized解决
    • 2.3 原子性
    • 2.4 AtomicInteger类
    • 2.5 悲观锁和乐观锁

前言

“清琴浊酒莺花日，雨笠烟蓑蟹稻乡。棠荫渐高身渐隐，已将心事托渔郎”   —张英 《赠何匡山次梅村先生韵》
在这里插入图片描述

1 线程池

1.1 线程池概述

       线程池也是可以看做成一个容器，在该容器中存储很多个线程。

1.1.1 线程池存在的意义

       系统创建一个线程的成本是比较高的，频繁的创建和销毁线程对系统的资源消耗非常大，所为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

1.1.2 Executors默认线程池

       1.常见方法

// 1.创建一个默认的线程池
static ExecutorService newCachedThreadPool()
// 2.创建一个指定最多线程数量的线程池
static newFixedThreadPool(int nThreads)

       2.代码实现 :

package com.syh;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


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

        // 1,创建一个默认的线程池对象
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
        // 2,等待2秒
        Thread.sleep(2000);
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
        executorService.shutdown();
    }
}

1.2 线程状态介绍

       线程对象在不同的时期有不同的状态，一共有6种状态

1.2.1 线程状态源码

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 

        /* 可运行状态 */
        RUNNABLE , 

        /* 阻塞状态 */
        BLOCKED , 

        /* 无限等待状态 */
        WAITING , 

        /* 计时等待 */
        TIMED_WAITING , 

        /* 终止 */
        TERMINATED;
    
	}
    
    // 获取当前线程的状态
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}

1.2.2 线程状态含义

线程状态具体含义
NEW一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED一个完全运行完成的线程的状态。也称之为终止状态、结束状态

1.2.3 线程状态转换图

在这里插入图片描述

2 原子性

2.1 volatile关键字

1. 问题 :

当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题

  • 堆内存是唯一的，每一个线程都有自己的线程栈。

  • 每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。

  • 在线程中，每一次使用是从变量的副本中获取的。

2. Volatile解决 : 强制线程每次在使用的时候，都会看一下共享区域最新的值,代码示例如下：

package com.syh;

public class Money{
    public static volatile int money = 1000;
}

package com.syh;

public class MyThread1 extends Thread{
    @Override
    public void run() {
        Money.money -= 100;
        System.out.println("李默然：" + Money.money);
    }
}

package com.syh;

public class MyThread2 extends Thread{
    @Override
    public void run() {
        System.out.println("林北辰：" + Money.money);
    }
}

package com.syh;

public class Test {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.start();
    }
}

2.2 synchronized解决

1. synchronized解决步骤 :

  • 线程获得锁

  • 清空变量副本

  • 拷贝共享变量最新的值到变量副本中

  • 执行代码

  • 将修改后变量副本中的值赋值给共享数据

  • 释放锁

2. 代码实现 :

package com.syh;

public class Money{
    public static Object lock = new Object();
    public static int money = 1000;
}

package com.syh;

public class MyThread1 extends Thread{
    @Override
    public void run() {
        synchronized (Money.lock){
            Money.money -= 100;
            System.out.println("李默然: " + Money.money);
        }
    }
}

package com.syh;

public class MyThread2 extends Thread{
    @Override
    public void run() {
        synchronized (Money.lock){
            System.out.println("林北辰：" + Money.money);
        }
    }
}

package com.syh;

public class Test {
    public static void main(String[] args) {
            MyThread1 t1 = new MyThread1();
            t1.start();

            MyThread2 t2 = new MyThread2();
            t2.start();
        }
}

2.3 原子性

       原子性就是要么所有的操作都执行，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

2.4 AtomicInteger类

java从JDK1.5开始提供了AtomicInteger类，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式，常用方法如下:

public AtomicInteger()：	   			    // 1.初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)： // 2.初始化一个指定值的原子型Integer

int get():   			 				 // 3.获取值
int getAndIncrement():      			 // 4.以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet():     				 // 5.以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data): // 6.以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value):   			 // 7.以原子方式设置为newValue的值，并返回旧值。

代码实现 :

package com.syh;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtom {
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);

        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }
}

2.5 悲观锁和乐观锁

synchronized和CAS的区别是什么?

1. 相同点
       在多线程情况下，都可以保证共享数据的安全性。

2.不同点

  • 悲观锁：synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每次操作共享数据之前，都会上锁。

  • 乐观锁：cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。


http://www.kler.cn/news/321319.html

相关文章：

  • 『功能项目』宠物的攻击巨型化【80】
  • 人力资源数据集分析(二)_随机森林与逻辑回归
  • JavaScript 学习
  • composer详解
  • day3 QT
  • 数据仓库-数据命名标准规范
  • Android入门
  • 【Vue】Vue3 的初始化过程
  • React Native实现推送通知
  • 免费使用！通过API将文字转换为拼音
  • 15分钟学Python 第22天 ：继承与多态
  • 铨顺宏科技携RTLS+RFID技术亮相工博会！
  • Python--循环
  • 数组组成的最小数字 - 华为OD统一考试(E卷)
  • OmniAns丨OPENAIGC开发者大赛高校组AI创作力奖
  • 即插即用篇 | DenseNet卷土重来! YOLOv8 引入全新密集连接卷积网络 | ECCV 2024
  • CentOs-Stream-9 解决此系统未向授权服务器注册问题
  • 行情叠加量化，占据市场先机！
  • 计算机网络1
  • 【数据结构】假设二叉树采用二叉链表存储，编写一棵二又树中序遍历的非递归算法。
  • Apache技术深度解析与实战案例
  • Pydantic 是一个强大的 Python 库
  • EVM理解：深入理解EVM的运作方式，包括Gas机制、交易执行流程等。
  • 【IOS】申请开发者账号（公司）
  • C++ 排序算法
  • 基于51单片机的方向盘模拟系统
  • OJ在线评测系统 后端 使用代理模式编写测试类 并 实现核心业务判题流程
  • 开源治理聚光灯 | 企业规模不同，治理方式各显神通
  • 【openwrt-21.02】VPN Passthrough系列之L2TP Passthrough实现
  • 谷神后端$vs.dbTools.list