二、Java并发编程：Java并发机制的底层原理

最新推荐文章于 2024-03-20 10:15:00 发布
最新推荐文章于 2024-03-20 10:15:00 发布
阅读量167 收藏
点赞数
分类专栏： # 09.Java 多线程 01.Java 文章标签： Java 并发 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KJGMan/article/details/90116910
版权

一、线程安全问题

1. 一个典型的线程不安全的例子

  1. 多个线程同时操作同一份资源的（主要是进行读写操作）时候，就有可能会发生线程安全问题；比如两个人同时对同一个账户进行取款操作的时候，就有可能会出现余额为负数的结果。
  2. 示例：两个人同时操作一个账户
package concurrency.account;

/**
 * 账户类,主要记录账户余额,以及提供取款方法
 * @author lt
 * @date 2018年7月2日
 * @version v1.0
 */
public class Account {
	private String accountNo;
	private double balance;
	public Account(String accountNo, double balance){
		this.accountNo = accountNo;
		this.balance = balance;
	}
	public String getAccountNo() {
		return accountNo;
	}
	public void setAccountNo(String accountNo) {
		this.accountNo = accountNo;
	}
	//账户余额不允许随便修改,故只提供get方法
	public double getBalance() {
		return balance;
	}
	public void draw(double drawAmount){
		//取钱数不能超过余额数
		if(balance>=drawAmount){
			System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			//修改余额
			balance -= drawAmount;
			System.out.println("\t余额为："+balance);
		} else {
			System.out.println("余额不足！取钱失败！");
		}
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((accountNo == null) ? 0 : accountNo.hashCode());
		long temp;
		temp = Double.doubleToLongBits(balance);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		if (Double.doubleToLongBits(balance) != Double
				.doubleToLongBits(other.balance))
			return false;
		return true;
	}
}


package concurrency.account;
/**
 * 取款操作的线程,继承Thread类
 * @author lt
 * @date 2018年7月2日
 * @version v1.0
 */
public class DrawThread extends Thread{

	private Account account;
	private double drawAmount;
	public DrawThread(String name, Account account, double drawAmount){
		super(name);
		this.account = account;
		this.drawAmount = drawAmount;
	}
	public void run(){
		account.draw(drawAmount);
	}
}


package concurrency.account;
/**
 * 测试类测试两个人同时操作同一个账户(取同一个账户的钱)
 * @author lt
 * @date 2018年7月2日
 * @version v1.0
 */
public class DrawTest {

	public static void main(String[] args) {
		for(int i=0; i<10; i++){
			Account account = new Account("0001", 1000);
			new DrawThread("甲", account, 800).start();
			new DrawThread("乙", account, 800).start();
		}
	}
}


/**
 * 输出结果
 */
乙取钱成功！吐出钞票：800.0
甲取钱成功！吐出钞票：800.0
	余额为：200.0
	余额为：-600.0

2. 解决方案：synchronized，lock

  1. synchronized修饰代码块
package concurrency.account;

/**
 * 线程同步:修饰代码块
 * @author lt
 * @date 2018年7月2日
 * @version v1.0
 */
public class Account {
	private String accountNo;
	private double balance;
	public Account(String accountNo, double balance){
		this.accountNo = accountNo;
		this.balance = balance;
	}
	public String getAccountNo() {
		return accountNo;
	}
	public void setAccountNo(String accountNo) {
		this.accountNo = accountNo;
	}
	//账户余额不允许随便修改,故只提供get方法
	public double getBalance() {
		return balance;
	}
	public void draw(double drawAmount){
		/**
		 * 一、synchronized加锁机制
		 * 1.synchronized关键字修饰代码块或者方法,同步监视器为this;
		 * 2.任何时刻,只能有一个线程获得同步监视器的锁,进而对资源进行操作;
		 * 二、synchronized释放锁
		 * 1.代码块正常终止或抛出异常;
		 * 2.调用同步监视器的wait()方法;
		 */
		synchronized(this){
			//取钱数不能超过余额数
			if(balance>=drawAmount){
				System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				//修改余额
				balance -= drawAmount;
				System.out.println("\t余额为："+balance);
			} else {
				System.out.println("余额不足！取钱失败！");
			}
		}
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((accountNo == null) ? 0 : accountNo.hashCode());
		long temp;
		temp = Double.doubleToLongBits(balance);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		if (Double.doubleToLongBits(balance) != Double
				.doubleToLongBits(other.balance))
			return false;
		return true;
	}
}
  1. synchronized修饰方法（不能修饰static方法）
package concurrency.account;

/**
 * 线程同步:修饰方法
 * @author lt
 * @date 2018年7月2日
 * @version v1.0
 */
public class Account {
	private String accountNo;
	private double balance;
	public Account(String accountNo, double balance){
		this.accountNo = accountNo;
		this.balance = balance;
	}
	public String getAccountNo() {
		return accountNo;
	}
	public void setAccountNo(String accountNo) {
		this.accountNo = accountNo;
	}
	//账户余额不允许随便修改,故只提供get方法
	public double getBalance() {
		return balance;
	}
	/**
	 * 一、synchronized加锁机制
	 * 1.synchronized关键字修饰代码块或者方法,同步监视器为this;
	 * 2.任何时刻,只能有一个线程获得同步监视器的锁,进而对资源进行操作;
	 * 二、synchronized释放锁
	 * 1.代码块正常终止或抛出异常;
	 * 2.调用同步监视器的wait()方法;
	 */
	public synchronized void draw(double drawAmount){
		//取钱数不能超过余额数
		if(balance>=drawAmount){
			System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			//修改余额
			balance -= drawAmount;
			System.out.println("\t余额为："+balance);
		} else {
			System.out.println("余额不足！取钱失败！");
		}
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((accountNo == null) ? 0 : accountNo.hashCode());
		long temp;
		temp = Double.doubleToLongBits(balance);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		if (Double.doubleToLongBits(balance) != Double
				.doubleToLongBits(other.balance))
			return false;
		return true;
	}
}
  1. luck加锁
package concurrency.account;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程同步
 * @author lt
 * @date 2018年7月2日
 * @version v1.0
 */
public class Account {
	private ReentrantLock lock = new ReentrantLock();
	private String accountNo;
	private double balance;
	public Account(String accountNo, double balance){
		this.accountNo = accountNo;
		this.balance = balance;
	}
	public String getAccountNo() {
		return accountNo;
	}
	public void setAccountNo(String accountNo) {
		this.accountNo = accountNo;
	}
	//账户余额不允许随便修改,故只提供get方法
	public double getBalance() {
		return balance;
	}
	/**
	 * 一、luck加锁机制
	 * 1.显示加锁,显示释放
	 */
	public void draw(double drawAmount){
		/**
		 * 加锁
		 */
		lock.lock();
		try{
			//取钱数不能超过余额数
			if(balance>=drawAmount){
				System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				//修改余额
				balance -= drawAmount;
				System.out.println("\t余额为："+balance);
			} else {
				System.out.println("余额不足！取钱失败！");
			}
		} finally {
			/**
			 * 释放
			 */
			lock.unlock();
		}
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((accountNo == null) ? 0 : accountNo.hashCode());
		long temp;
		temp = Double.doubleToLongBits(balance);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		if (Double.doubleToLongBits(balance) != Double
				.doubleToLongBits(other.balance))
			return false;
		return true;
	}
}

通过上边的案例，我们了解到，在使用多线程的时候，可能会发生线程安全的问题，加锁是处理线程安全问题的常见方式，接下来，就来深入了解一下Java并发机制的底层原理，这样做可以更好的使用并多线程来解决问题

二、volatile

用于保证共享变量在多个线程之间的可见性（当一个线程修改变量时，其他线程可以读取到修改的值），不会引起线程上下文的切换与调度，是轻量级的synchronized

1. volatile的定义与实现原理

定义：当一个变量被volatile修饰，Java线程内存模型保证任一线程对此变量的修改，其他线程均可读取到修改的值

原理：

三、synchronized

1. 简介

synchronized用于修饰代码块或者方法，被synchronized修饰的代码块或者方法，同一时间只能有一个线程在执行，其余线程只能等待该线程执行结束后才能继续执行；

2. 原理

由JVM规范可以了解，synchronized在JVM底层基于monitor对象的进入和退出来实现方法和代码块的同步；对于代码块同步使用的是monitorenter和monitorexit指令实现；monitorenter在代码编译后插入同步代码块的开始位置，monitorexit插入结束和异常位置；每一个对象都有一个monitor对象与之关联，当monitor对象被线程持有时，对象处于锁定状态

3. 作用

synchronized的作用主要有三个：

  1. 确保线程互斥的访问同步代码；
  2. 保证共享变量的修改能够及时可见；
  3. 有效解决重排序问题；

4. 用法

从语法上讲，Synchronized总共有三种用法：

  1. 修饰普通方法
  2. 修饰静态方法
  3. 修饰代码块

5. synchronized优化

使用监视器monitor来实现，而监视器monitor依赖于底层操作系统的Mutex Lock来实现。基于Mutex Lock进行线程切换时间较长，成本较高，所以称synchronized为重量级锁。为了提高性能，JDK1.6之后，引入了偏向锁，轻量级锁

6. 偏向锁

Java SE 1.6为了减少获得锁和释放锁时的资源消耗，引入了偏向锁和轻量锁，至此Java中的锁有四种状态，级别由低到高：无锁状态，偏向锁状态，轻量级锁状态，重量级锁状态；锁可以升级但是不能降级；锁的状态保存在对象头中，以32位JDK为例：

锁状态

25 bit

4bit

1bit2bit
23bit2bit是否是偏向锁锁标志位
轻量级锁指向栈中锁记录的指针00
重量级锁指向互斥量（重量级锁）的指针10
GC标记空11
偏向锁线程IDEpoch对象分代年龄101
无锁对象的hashCode对象分代年龄001

定义：偏向锁更像一种策略，用于降低多个线程在竞争获取锁的代价；它是通过在对象头和栈帧中记录偏向锁的线程ID，之后线程在进入和退出同步块时不需要CAS操作来加锁和解锁；当其他线程竞争锁的时候，偏向锁会撤销；Java 6和Java 7中默认启用偏向锁；可以通过-XX:BiasedLocking来禁用偏向锁；

7. 轻量级锁

8. 锁的优缺点对比

在这里插入图片描述

四、原子操作的实现原理

原子操作是指不可中断的一个操作或者一系列操作

1. 处理器如何实现原子操作

32位IA-32处理器通过总线加锁或缓存加锁的方式实现原子操作

1. 通过总线锁保证原子性

举个栗子：两个处理器执行同一条指令：i++，（i++指令可以拆分成三步：第一步，从内存中读取i的值；第二步，i+1；第三步，i赋值）；两个处理器在同时执行时，有可能会发生这种情况：cpu1和cpu2并行执行第1，2，3步，执行完成后，内存中的i的值为2；多个处理器的情况下，这是有可能发生的；为了保证原子性操作，可以使用处理器提供的总线锁，在cpu1执行时，使用总线锁在总线上输出Lock#信号，其他处理器被阻塞，cpu1独占内存

2. 通过缓存锁保证原子性

通过总线锁的说明可知：总线锁锁住了其他cpu和内存之间的通信，开销巨大；缓存锁是指在修改缓存中的数据时，修改完成后，缓存回写到内存中，其他cpu重新从内存中读取

3. 不能使用缓存锁的情况
  1. 共享数据不在缓存中
  2. 不支持缓存的处理器

2. Java如何实现原子操作

1. 利用循环CAS实现原子操作

CAS（Compare and swap），即比较并交换；JVM的CAS利用的是处理器的CMPXCHG指令实现的；自旋CAS的核心操作即：循环进行CAS操作，直至成功为止；CAS也是实现我们平时所说的自旋锁或乐观锁的核心操作

示例

下面的例子展示了线程安全的计数器和非线程安全的计数器，其中线程安全的计数器是利用JUC中的Atomic包下的相关类来实现

package com.lt.thread04;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 1.验证Java利用循环CAS验证操作完成原子操作
 * @author lt
 * @date 2019年5月11日
 * @version v1.0
 */
public class Counter {

	private int m = 0;
	private AtomicInteger n = new AtomicInteger();
	//非线程安全的计数方法
	public void count(){
		m++;
	}
	//利用JUC的相关类实现线程安全的计数器（CAS）
	public void safeCount(){
		//循环进行CAS操作，直至成功为止
		while(true){
			int i = n.get();
			//如果当前值==期望值，则以原子方式将值设置为给定的更新值。相当于i=++i
			boolean flag = n.compareAndSet(i, ++i);
			//如果设置成功，则跳出循环，否则继续设置
			if(flag) break;
		}
	}
	public static void main(String[] args) throws Exception {
		Counter c = new Counter();
		List<Thread> ts = new ArrayList<>();
		for(int i=0; i<1000; i++){
			Thread t = new Thread(new Runnable() {
				@Override
				public void run() {
					c.count();
					c.safeCount();
				}
			}, "线程"+i);
			ts.add(t);
		}
		for(Thread t : ts){
			t.start();
		}
		//等待当前线程执行完毕
		for(Thread t : ts){
			t.join();
		}
		System.out.println(c.m);
		System.out.println(c.n);
	}
}
结果
996
1000
注意

使用CAS会存在两个问题

  1. ABA问题：一个变量初始值是A，变成了B，又变成了A；在CAS操作时，认为变量没有发生变化；解决方式是加版本号：1A->2B->3C；Java中提供了AtomicStampedReference类来解决ABA问题
  2. 循环时间长开销大：当设置值不成功时，会循环进行CAS操作，占用CPU，造成开销过大
2. 利用锁

Java中第二种原子操作的方式是利用锁：偏向锁，轻量级锁，互斥锁（重量级锁）；其实除了偏向锁，轻量级锁和互斥锁的实现原理也是利用CAS操作，来获取锁和释放锁

五、死锁

  1. 死锁：当两个线程互相等待对方释放同步监视器时就会发生死锁
package concurrency.deadlock;
/**
 * 死锁验证
 * @author lt
 * @date 2018年7月3日
 * @version v1.0
 */
public class DeadLock {

	public static void main(String[] args) {
		final A a = new A();
		final B b = new B();
		new Thread(new Runnable() {
			@Override
			public void run() {
				a.invoke(b);
			}
		}, "线程1").start();;
		new Thread(new Runnable() {
			@Override
			public void run() {
				b.invoke(a);
			}
		}, "线程2").start();;
	}
}
class A{
	//① 线程一调用A的invoke()方法,并对a对象进行加锁
	public synchronized void invoke(B b){
		System.out.println(Thread.currentThread().getName()+"进入A的invlke()方法");
		//② 线程一休眠100毫秒,CPU切换执行线程二
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//⑤ 线程一继续运行,调用B的print方法,但是b对象在第③步被加锁,没有释放锁,所以线程阻塞等待锁释放
		b.print();
	}
	public synchronized void print(){
		System.out.println("A的print()方法");
	}
}
class B{
	//③ 线程二调用B的invoke()方法,并对b对象进行加锁
	public synchronized void invoke(A a){
		System.out.println(Thread.currentThread().getName()+"进入B的invlke()方法");
		//④ 线程二休眠100毫秒,CPU切换执行线程一
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//⑥ 线程二继续运行,调用A的print方法,但是a对象在第①步被加锁,没有释放锁,所以线程阻塞等待锁释放
		a.print();
	}
	public synchronized void print(){
		System.out.println("B的print()方法");
	}
}

参考资料

【1】Java总结篇系列：Java多线程（三）
【2】Java多线程系列目录(共43篇)
【3】Java并发编程的艺术
【4】Java并发编程：Synchronized底层优化（偏向锁、轻量级锁）
Lizza~
关注
专栏目录
Java 并发编程：volatile 关键字介绍与使用
栗筝i的博客
08-04 2852
volatile关键字在 Java 中用于修饰变量，使其具有可见性和有序性。可见性：在多线程环境下，当一个线程修改了volatile变量的值，新值对于其他线程是立即可见的。通常情况下，线程之间对变量的读写操作是不可见的，这意味着一个线程修改了变量的值，另一个线程可能看不到这个修改，仍然使用旧值。使用volatile关键字可以确保所有线程看到的是变量的最新值；volatile关键字还可以防止指令重排序优化。编译器和处理器通常会对指令进行重排序，以提高性能，但这种重排序可能会破坏多线程程序的正确性。
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7515
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
Java并发编程：可见性、原子性和有序性问题
海陆云的博客
12-29 2万+
文章目录前言并发程序幕后的故事源头之一：缓存导致的可见性问题源头之二：线程切换带来的原子性问题源头之三：编译优化带来的有序性问题 前言 如果你细心观察的话，你会发现，不管是哪一门编程语言，并发类的知识都是在高级篇里。换句话说，这块知识点其实对于程序员来说，是比较进阶的知识。我自己这么多年学习过来，也确实觉得并发是比较难的，因为它会涉及到很多的底层知识，比如若你对操作系统相关的知识一无所知的话，那去理解一些原理就会费些力气。这是我们整个专栏的第一篇文章，我说这些话的意思是如果你在中间遇到自己没想通的问题，
Java并发编程-线程池底层工作原理
Java硬件工程师的博客
01-29 2462
关于线程池的具体介绍，可以参看ThreadPool线程池，这里主要介绍线程池底层工作原理。 1.线程池的底层工作原理 1.1.线程池的底层工作原理图 线程池的主要处理原理图和流程图如下 1.2.银行办理业务案例 为了便于理解，我们用银行的例子来说明银行网=线程池 corePoolsize=今日当值窗口。今日当值窗口由两个，当银行客人来了之后，先去候客厅等着，现在来了3个即3，4，5都来了，在候客厅等着，此时候客区也满了。突然，6，7，8三个人又来了，由于候客区也满了，此时可以用到maximumPoolS
【java并发编程】底层原理——锁分类和java锁机制
Wonder ZH
02-22 5237
一、什么是锁？ 在计算机科学中，锁(lock)或互斥(mutex)是一种同步机制，用于在有许多执行线程的环境中强制对资源的访问限制。锁旨在强制实施互斥排他、并发控制策略。 锁通常需要硬件支持才能有效实施。这种支持通常采取一个或多个原子指令的形式，如"test-and-set", "fetch-and-add" or "compare-and-swap"”。这些指令允许单个进程测试...
Java高并发编程实战4，synchronized与Lock底层原理
学Java，找哪吒
09-23 4875
Java高并发编程实战系列，打造精品专栏。
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java并发编程的艺术
qq_36811160的博客
07-19 1847
Java并发编程的艺术读书笔记
Java多线程：并发编程的挑战+Java并发机制的底层实现原理
hxt的博客
02-06 2517
最近开始学习Java多线程相关的知识了，想要基础入门的话推荐读《Java多线程编程核心技术》，内容偏实战，想要深入理解多线程的话推荐读《Java并发编程的艺术》和《Java并发编程实战》，最近的话在看《Java并发编程的艺术》，看的同时做一下相关的记录 一、并发编程的挑战 1、上下文切换 单核处理器也支持多线程执行代码，CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线...
Java并发编程：核心理论
12-22
并发编程是Java程序员重要的技能之一，也是难掌握的一种技能。它要求编程者对计算机底层的运作原理有深刻的理解，同时要求编程者逻辑清晰、思维缜密，这样才能写出高效、安全、可靠的多线程并发程序。本系列会从线程...
Java并发编程：Synchronized及其实现原理
12-22
Java并发编程中的Synchronized关键字是实现线程安全的关键工具，它提供了锁机制，确保了多线程环境下的数据一致性与安全性。以下将详细介绍Synchronized的使用及其实现原理。 一、Synchronized基本使用 1. 修饰...
java：并发编程的两本书《Java并发编程实战》 《Java并发编程的艺术》 PDF
09-09
《Java并发编程的艺术》是一本全面探讨Java并发编程技术的专业书籍，它深入剖析了Java并发机制的底层实现，如volatile、synchronized等关键技术的工作原理，并详细讲解了线程池、并发容器等高级并发工具的使用。...
pytz-2022.6-py2.py3-none-any.whl
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
VB程序实例-禁用IE[查看]菜单下[工具栏]中的子菜单.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享ZigBee-Specification（2007）非常好的技术资料.zip
11-03
技术资料分享ZigBee-Specification（2007）非常好的技术资料.zip
VB程序实例-房态状态管理.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
VB程序实例82_Foleder操作_建立删除文件.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
Screenshot_2024-11-03-14-05-43-43.jpg
11-03
Screenshot_2024-11-03-14-05-43-43.jpg
Java并发编程：JUC工具包与底层原理解析
Java并发编程是Java程序设计中的重要组成部分，尤其是Java Util Concurrent (JUC) 工具包，自JDK 1.5引入以来，它极大地简化了多线程和并发控制的实现。JUC包提供了各种高级并发组件，如线程池、同步器、锁等，旨在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值