1.并发三要素
-
原子性:
java中指,一个或多个操作,要么全部执行成功,要么全部执行失败。 -
有序性:
程序执行的顺序要按照代码的先后顺序。 -
可见性:
当多个线程访问同一个变量时,如果其中一个线程对变量做了修改,其他线程要立即获取到最新的值。
2.线程的五大状态
-
创建:
用new操作创建一个线程的时候。 -
就绪:
调用start方法,处于就绪状态的线程,并不一定马上调用run方法执行,还要等待cpu的调度。 -
运行:
cpu开始调度线程,并开始执行run方法。 -
阻塞:
线程的执行过程中由于一些原因进入阻塞状态,比如,执行sleep方法,或者尝试获取一个锁等。 -
死亡:
run方法执行完,或者遇到异常。
3.悲观锁和乐观锁
-
悲观锁:
每次操作都会加锁,造成线程阻塞。 -
乐观锁:
每次操作都不加锁,假设没有冲突去完成某些操作,如果因为冲突失败就重试,直到成功为止,不会造成线程阻塞。
4.线程之间协作
4.1wait、notify、notifyAll(这是一组Object类方法,必须在同步范围内调用)
-
wait:
wait有三种方式唤醒,notify、notyfyAll或者wait(longtimeout),其中longtimeout如果没有notify或者notifyAll也会在指定时间内唤醒。 -
notify
只能唤醒一个处于wait()的线程。 -
notifyAll
唤醒全部处于wait()的线程。
4.2sleep、yield、join(这是一组Thread类的方法)
-
sleep
让当前线程暂停指定之间,只是让出cpu的使用权,并不释放锁 -
yield
暂停当前线程的执行,让出当前cpu的使用权,不能指定时间,会使当前线程从运行状态变为就绪状态,在生产中很少使用。 -
join
等待调用jion方法后,才执行后面的代码,此方法一定要在start后用。
场景:当主线程需要等待子线程执行结束后才执行后面的操作
wait和join对比:
1.wait是 Object 类中的方法,join是 Thread 类中的方法。
2.sleep方法调用后不会释放做,线程仍然可以同步控制,不会让出系统资源,而wait进入线程等待池中等待,让出系统资源。
3.调用wait方法的线程不会自动唤醒,需要线程调用notify或者notifyAll,才会进入就绪队列中等待系统分配资源;而sleep方法会自动唤醒,如果时间不到,想要唤醒,可以使用interrupt强制打断。
使用范围:
sleep可以在任何地方使用,而wait、notify、notifyAll只能在同步方法或同步块中使用。
sleep必须捕获异常,而wait、notify、notifyAll不需要。
5.volatile
5.1 是什么:
被volatile声明的变量在内存模型中可被全局可见,volatile是轻量级的sychronized,不会引起线程上下文切换和调度,开销更小。
5.2 原理:
- 使用volatile修饰的变量,在汇编阶段,会多出一条lock前缀的指令。
- 会强制将对内存的修改操作立即写入主存。
- 如果是写操作,会导致其他cpu里缓存了该内存地址大数据无效。
5.3 作用:
- 内存可见
- 多线程操作的时候,一个线程修改了一个变量的值,其他线程能够立即看到修改后的值。
- 全局可见,但是,不能保证原子性。
volatile不是并发安全举例:
两个线程A、B同时修改一个int i=5,A执行i++,B同时执行i++,写回主存后都是6,但是,其实 i 执行了两次++
6.sychronized
确保线程互斥的访问同步
6.1定义:
sychronized是jvm实现的一种锁,锁的获取和释放分别是monitorenter和monitorenxit指令,在实现上分为了:偏向锁、轻量级锁和重量级锁,偏向锁在jdk1.6是默认开启,轻量锁在多线程竞争情况下会膨胀成重量级锁,有关锁的数据都保存在对象头中。
6.2作用:
- 修饰普通方法(同步对象是实例对象)
- 修饰静态方法(同步对象是类本身)
- 修饰代码块 (可以自己设置同步对象)
6.3缺点:
会让没有得到锁的资源进入Block状态,争夺资源后又转为Running状态,这个过程涉及到操作系统用户模式和内核模式的切换,代价很高,java1.6后对sychronized做了优化,增加了偏向锁到轻量锁到重量锁的过程,但是最终转变为重量锁之后,性能仍然很低。
7.CAS
7.1描述:
AtomicBoolean、AtomicInteger、AtomicLong以及lock相关的类等底层都是CAS 实现的,性能比sychronized更高。
7.2是什么:
全称,compare and set(swap),即比较和替换,操作包含三个操作数,内存位置(v),预期原值(A)和新值(B),如果内存位置和预期原值相匹配,处理器将自动将该位置的值更新为新值,否则,处理器不做任何处理。
7.3为什么会出现CAS:
- 如果只用sychronized保证同步会造成如下问题:
sychronized是一种悲观锁,使用上会造成一定性能问题。在多线程竞争下,加锁、释放锁会导致较多的上下文切换和调度延时,一个线程持有锁后,会导致其他所有需要此锁的线程挂起。
7.4实现原理:
java不能直接访问操作系统底层,通过native(jni)来访问。CAS底层通过unsafe类实现原子操作。
7.5存在的问题:
ABA问题:
比如,int N = 1,此时有三个线程想去改变N:
线程A:希望给N赋值为2
线程B:希望给N赋值为2
线程C:希望给N赋值为1
此时,线程A和B同时获取N为1,A率先获得系统资源,将N=2,B由于某种原因被阻塞,C在A执行完毕后获得N当前值为2,然后把1赋给了N。
最后B获得了系统资源,又恢复了运行状态,此时,在阻塞前,B取到的值为1,执行compare后发现,当前N的值还是1,然后成功将N赋值为2。
在这个过程中,B阻塞时获取到N的旧值是1,虽然和当前值(被C修改后)相等,但实际上N经历过了一次1->2->1的改变。
这就是典型的ABA的问题。
7.6如何解决:
给变量增加一个版本号即可,在比较的时候不仅要比较当前变量值,还要比较当前变量的版本号,java中,AtomicStampedReference就解决了这个问题。
在并发高的环境下,如果许多线程反复尝试更新一个变量,却一直更新不成功,循环往复,会给cpu带来很大压力,CAS只能保证一个共享变量的原子操作。
8.AQS(AbstraceQueuedSynchronizer)
8.1是什么:
即:抽象的队列同步器,是一种基于状态(state)的链表管理方式,state是由CAS去修改状态,state的修饰关键字是volatile。
AQS定义了一套多线程访问共享资源的同步框架,是java.util.concurent包中的重要基石,许多同步类的实现都基于CAS,比如ReentractLock、CountDownLatch、Semaphoer等。
8.2 ReentractLock(显示锁、互斥锁、可重入锁)
- ReentractLock实现了java.util.concurrent.lock
- 性能更佳,当多线程都想访问共享资源时,jvm可以花更少的时间来调度线程,把更多的时间用在执行线程上。
- ReentrackLock获取方式:
1.lock(),获取锁后立即返回,如果其他线程持有锁,当前线程一直处于休眠状态,知道获取锁。
2.tryLock(),如果获取了锁,立即返回true,如果别的线程正持有锁,立即返回false。
3.tryLock(long timeout,TimeUtil util),如果获取了锁,立即返回true,如果其他线程正在持有锁,会等参数给定的时间,在等待过程中,如果持有立即返回true,如果没有,返回fase。
4.lockInterruptibly,如果获得锁立即返回,如果没有,当前线程处于休眠状态,直到获得锁,或当前线程被其他线程中断。
//代码段
Lock lock = new ReentractLock();//参数默认false,不公平锁
lock.lock();
try{//Todo
}finally{
lock.unlock
}
ReentractLock和Synchronized对比: (都是互斥锁)
1.除了实现同步外,添加了类似锁投票、定时锁等候和可中断锁的一些特征。
2.lock必须在finally块中释放锁
3.线程ab都要获取c,a先获取到了c的锁,synchronized会一直等待a的释放,不中断;reentracklock如果a一直不释放,可以使b等了足够时间后,中断等待,去做别的事。
4.Synchronized是jvm层面上的,不但可以通过监控工具监控synchronized的状态,而且如果出现异常,jvm会自动释放锁,但是lock不行,lock是接口,通过代码实现。
5.在竞争不是很激烈的情况下,synchronized的性能要优于ReentrackLock,竞争激烈的情况下Synchronized性能会下降几十倍,但是reentracklock性能则维持常态。
6.Synchronized是非公平锁,ReentrackLock 可以 设置为公平锁:
cpu调度线程会在等待队列里随机选,这样会产生饥饿现象,公平锁可以按照等待的时间先后顺序执行(大体是这样,不一定)
//创建公平锁,入参为true,默认是非公平false
private static ReentrantLock lock=new ReentrantLock(true);
//reentracklock创建内部实现
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
7.内置锁(synchronized)和Lock都是重入锁、互斥锁:
当一个线程得到一个对象后,再次请求该对象锁时是可以得到锁的,自己可以再次获取自己的内部锁,如下:
调用method1()时,已经获得了锁,调用内部method2时,由于本身已经具有锁,所以可以再次获取。
public class SynchronizedTest {
public void method1() {
synchronized (SynchronizedTest.class) {
System.out.println("方法1获得ReentrantTest的锁运行了");
method2();
}
}
public void method2() {
synchronized (SynchronizedTest.class) {
System.out.println("方法1里面调用的方法2重入锁,也正常运行了");
}
}
public static void main(String[] args) {
new SynchronizedTest().method1();
}
}
public class ReentrantLockTest {
private Lock lock = new ReentrantLock();
public void method1() {
lock.lock();
try {
System.out.println("方法1获得ReentrantLock锁运行了");
method2();
} finally {
lock.unlock();
}
}
public void method2() {
lock.lock();
try {
System.out.println("方法1里面调用的方法2重入ReentrantLock锁,也正常运行了");
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
new ReentrantLockTest().method1();
}
}
8.lock知道有没有成功获取到锁,syn不可以。
9.lock可以提高多线程进行读操作的效率。
6.Atomic,竞争不激烈的情况下,比syn性能略低,激烈情况下性能优于syn,但是,缺点,一段代码中只能出现一个Atomic,多于1个,则同步无效,不能在多个Atomic之间同步。
7.两个的开销差距是在释放锁时唤醒线程的数量,Synchronized是唤醒锁里池里所有线程+刚好来访问的线程,reetrancklock是当前线程后,进来的第一个线程+刚好来范文的线程。
- 在用的时候优先考虑Synchronized,如果reentrakclock和Atomic用的不好,可能会带来灾难。
- 如果线程可以在30-50次之间自旋里拿到锁,Synchronized就不会升级为重量锁,等待线程也不会被挂起,也就减少了挂起和唤醒和上限为切换的开销。
8.3 ReadWriteLock读写锁
- 读写锁ReadWriteLock是一个接口,ReentractReadWriteLock实现了这个接口
- 读写锁将一个自由的访问分成两个锁,一个读,一个写。
- 多线程之间读操作可以并发访问,不需要同步,写操作需要同步,提高了效率,适用于读多写少的场景。
- 可以通过readLock()获取读锁,writeLock()获取写锁。
- 可实现功能:释放优先、读线程插队、重入性、降级、升级
ReadWriteLock接口代码:
publi interface ReadWriteLock(){
Lock readLock();
Lock writeLock();
}
ReentrantReadWriteLock(),提供了公平锁和费公平锁两种创建方式:
设计一个缓存,利用读写锁(读数据用读锁,写数据用写锁):
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteCatch {
private ConcurrentHashMap<String,Object> safeHashMap = new ConcurrentHashMap();
private ReadWriteLock rw = new ReentrantReadWriteLock();
public String getKey(String key){
Object value = null;
rw.readLock().lock();//获取读锁
try{
value = safeHashMap.get(key);
if(value == null){//缓存中没有该值,从数据库获取,并写入缓存
rw.readLock().unlock();//释放读锁,获取写锁,查出数据后,写入缓存
rw.writeLock().lock();
try{
if(value == null){
System.out.println("从数据库取值…… ……");
value = "张三";
safeHashMap.put(key,value);
}
}finally {
rw.writeLock().unlock();
}
rw.readLock().lock();//写入缓存完毕后,重新获取读锁
}else{
System.out.println("从缓存中获取值…… ……");
}
}finally {
rw.readLock().unlock();//释放读锁
}
return value==null ? null : String.valueOf(value);
}
public static void main(String[] str){
ReadWriteCatch rwc = new ReadWriteCatch();
for (int i=0;i<3;i++) {
System.out.println(rwc.getKey("1"));
}
}
}
9.Future
在并发编程中,一般使用Runable执行异步任务,但是这样并不能拿到异步任务的返回值,但是Future可以,使用时,把Runable换成FutureTask即可。
10.ThreadLocal
10.1是什么:
- 代表一个线程局部变量,每个线程都有一个副本,线程之间相互独立,只能看到自己的值,并不会意识到其他线程中也有该变量。
- 采用空间换时间的方式,解决多线程间相同变量的冲突问题。
10.2原理:
- 每个Thread对象,都有一个ThreadLocalMap,当创建ThreadLocal时,就会将该ThreadLocal对象添加到Map中,其中键是ThreadLocal,值可以是任意类型。
- 在该类中,最重要是的是set()、get()两个方法,当调用get()方法时,会先找到当前线程的ThreadLocalMap,然后再找对应的值。
get()找自己的副本变量。
10.3使用场景
- 数据库连接池、session
10.4代码实现
- ThreadLocal的接口方法:
1.void set(Object value)
2.public Object get()
3.public void remove() 删除当前线程局部变量的值
4.protected Object initalValue() 返回当前线程局部变量的初始值
public class Test {
//初始化tl为0
static ThreadLocal<Integer> tl = new ThreadLocal<Integer>(){
protected Integer initialValue(){
return 0;
}
};
//设置副本+1
public static Integer getNextTl(){
tl.set(tl.get()+1);
return tl.get();
}
//每组3个线程去读自己副本的值
public static class ThreadClient extends Thread{
public void run() {
for(int i=0;i<3;i++){
System.out.println("ThreadName:"+Thread.currentThread().getName()+",下个值:"+getNextTl());
}
}
}
//启动3个线程
public static void main(String[] arg){
ThreadClient t1 = new ThreadClient();
ThreadClient t2 = new ThreadClient();
ThreadClient t3 = new ThreadClient();
t1.start();
t2.start();
t3.start();
}
}
结果集:每组线程获取到的值互不影响
ThreadName:Thread-0,下个值:1
ThreadName:Thread-0,下个值:2
ThreadName:Thread-0,下个值:3
ThreadName:Thread-1,下个值:1
ThreadName:Thread-1,下个值:2
ThreadName:Thread-1,下个值:3
ThreadName:Thread-2,下个值:1
ThreadName:Thread-2,下个值:2
ThreadName:Thread-2,下个值:3
10.线程池
线程池通过线程复用大大减少了创建和销毁带来的性能上的损耗。