1.前言
在JAVA内存模型(JMM)中已经讲解了为了提高处理器的效率,实现"高并发"的效果,在处理器和存储设备之间加入高速缓存来作为缓冲.因此,使用多线程可以更好的利用cpu资源.
2.目录
目录
3.多线程
3.1.相关概念
进程:是程序一次执行过程,是系统运行程序的基本单位.系统运行一个程序即是一个进程从创建,运行到消亡的过程.一个进程就是一个执行中的程序,每个进程占有系统资源(如cpu时间,内存空间,文件,输入输出设备的使用权等).程序执行时,将被载入操作系统载入内存中
线程:线程是比进程更小的执行单位.一个进程在执行的过程中可以产生多个线程,多个线程共享同一块内存空间和一组系统资源.因此系统在创建线程,切换线程,负担比进程小得多,被称作轻量级进程
多线程:在同一时间点,运行多个线程(一个处理器在某一个时间点上永远都只能是一个线程,即使这个处理器是多核的,除非有多个处理器才能实现多个线程同时运行).这里的同一时间点实际上一个线程执行一会然后其他线程再执行
并行:当有多个线程在操作时,如果只有一个cpu,cpu将运行时间划分成若干个时间段,再讲时间段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状态
并发:当一个cpu执行一个线程时,另一个cpu可以执行另一个线程,两个线程互不抢占cpu资源,可以同时进行
3.2.线程状态
线程状态
调用join()和sleep()方法,结束时都会回到Runnable状态,等待JVM调度
调用wait(),使该线程处于等待池(wait blocked pool),直到notify()/notifyAll(),线程被唤醒被放到锁定池(lock blocked pool),释放同步锁使线程回到可运行状态(Runnable)
对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool),同步锁被释放进入可运行状态(Runnable)
yleld()方法可以让一个running转台的线程转入runnable
3.3.同步机制
synchronized:可用来给对象,方法或者代码块加锁,锁定的是一个方法或者代码块时,同一时刻最多只有一个线程执行这段代码.当两个并发线程访问同一个对象object中的这个加锁同步代码块,一个时间内只有一个线程能得到执行
monitor:java中的每个对象都有一个监视器,来监测并发代码的重入,在synchronized范围内,监视器发挥作用
wait/notify:必须存在于synchronized块中,这三个关键字针对的是同一个监视器,wait后,其它线程可以进入同步块执行
当代码并不持有监视器的使用权时,wait或notify会抛出java.lang.IIIegalMonitorStateException
volatile:多线程的内存模型中,处理数据时,线程会把值从主存load到本地栈,完成操作后再save回去(volatile作用:每次针对该变量的操作都激发一次load and save).同一实例的同一属性本身只有一个副本,但是多线程会缓存值,volatile不取缓存,直接取值,在线程安全的情况下加volatile会牺牲性能
3.4.线程基本类
Thread类重写run方法
new Thread(){
@Override
public void run() {
super.run();
System.out.println("Thread重写run方法开启一个线程");
}
}.start();
将Runnable接口传入Thread的构造器中
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("构造器传入runnable开启一个线程");
}
}).start();
Callable:future模式,get()返回具体值,会阻塞,isDone返回boolean值,是否执行完毕,不会阻塞
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(3);
MyCallable myCallable = new MyCallable();
Future future = executorService.submit(myCallable);
boolean doneBefore = future.isDone();
System.out.println(doneBefore);
String s = future.get();
System.out.println(s);
boolean doneAfter = future.isDone();
System.out.println(doneAfter);
//或者
MyCallable myCallableThread = new MyCallable();
FutureTask stringFutureTask = new FutureTask<>(myCallableThread);
new Thread(stringFutureTask).start();
}
static class MyCallable implements Callable {
@Override
public String call() throws Exception {
Thread.sleep(1000L);
System.out.println("---1s后----");
return "测试";
}
}
}
false
---1s后----
测试
true
---1s后----
3.5.高级多线程控制类
java1.5提供了一个非常高效实用的多线程包java.util.concurrent,提供了大量高级工具,帮助开发者编写高效,易维护,结构清晰的多线程程序
3.5.1.ThreadLocal类
作用:保存线程的独立变量,对于一个线程类,当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的副本变量,所以每一个线程都可以独立地改变自己的副本,而不会影响其他线程所对应的副本.常用语用户的登录控制,如记录session信息.
实现:每个Thread都持有一个ThreadLocalmap类型的变量,以本身为key,亩变为value.主要方法是get()和set(),set之后再map里维护一个threadLocal →a,get()时将a返回.ThradLocal是一个特殊的容器
ThreadLocal threadLocal = new ThreadLocal<>();
threadLocal.set("main");
new Thread(){
@Override
public void run() {
super.run();
threadLocal.set("Thread");
System.out.println(threadLocal.get() + "==" + threadLocal);
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
threadLocal.set("runnable");
System.out.println(threadLocal.get() + "==" + threadLocal);
}
}).start();
System.out.println("主:" + threadLocal.get() + "==" + threadLocal);
Thread==java.lang.ThreadLocal@1225de4d
主:main==java.lang.ThreadLocal@1225de4d
runnable==java.lang.ThreadLocal@1225de4d
3.5.2.原子类(AtomicInteger,AtomicBoolean...)
使用atomic wrapper class,如AtomicInteger,或者使用自己保证原子的操作,则等同于synchronized
public class AtomicTest {
private static AtomicInteger mAtomicInteger = new AtomicInteger(0);
public static void main(String[] args) {
new Thread(AtomicTest::printAdd,"线程1").start();
new Thread(AtomicTest::printAdd,"线程2").start();
}
private static void printAdd() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + "→" + mAtomicInteger.addAndGet(1));
}
}
}
线程1→1
线程1→3
线程1→4
线程2→2
线程2→5
线程2→6
addAndGet(int):以原子的方式将输入的值ActomicInteger中的值进行相加,返回相加后的值
CAS(Compare And Swap):即比较和交换,执行函数:CAS(V,E,N),内存位置(V),预期原值(E)和新值(N).从V上取值与E比较,如果与预期结果相等,则更新
//boolean值表示是否与期待值一致
public final boolean compareAndSet(int expect, int update) {
return U.compareAndSwapInt(this, VALUE, expect, update);
}
//此方法使用与乐观锁
if(b.value.compareAndSet(old, value)){
return ;
}else{
//try again
// if that fails, rollback and log
}
CAS自旋:乐观锁模式下,没有了锁概念,每条线程都直接先执行操作,计算完成后检测是否与其它线程存在共享数据竞争,如果没有则让此操作成功,如果存在共享数据竞争则可能不断地重新执行操作和检测,直到成功为止
CAS隐患
ABA问题,A改为B,又改为A,检测符合预期,实际发生了变化,解决方案就是追加版本号,JDK的Atomic包提供了类AtomicStampedReference,使用compareAndSet方法先检测当前引用是否等于预期引用,再判断当前标志是否等于预期标志
循环时间开销太大
当某一线程每次获取的值都被其他线程修改了,那么它会一直进行自旋比较,直到成功为止,cpu开销十分大
3.5.3.Lock类
lock:在java.util.concurrent包内
ReentrantLock
ReentrantReadWriteLock.ReadLock
ReentrantReadWriteLock.WriteLock
主要目的是和synchronized一样,两者都是为了解决同步的问题,处理资源争端而产生的技术.功能类似但有一些区别
lock更灵活,可以自由定义多把锁的加锁解锁顺序(synchronized要按照先加后解顺序)提供多种加锁方案,lock阻塞式,tryLock无阻塞式,lockInterruptily可打断式,还有tryLock的带超时时间版本,本质上和监视器锁(即synchronize是一样的)
和Condition类结合性能更高
ReentrantLock
可重入的意义在于持有锁的线程可以继续持有,并且要释放对等的次数后才真正释放该锁
//创建实例
ReentrantLock r=new ReentrantLock();
//加锁
r.lock()或r.lockInterruptibly();
//释放锁 可以放在final块中
r.unlock()
ReentrantReadWriteLock
可重入读写锁
ReentrantReadWriteLock lock = new ReentrantReadWriteLock()
ReadLock r = lock.readLock();
WriteLock w = lock.writeLock();
两者都有lock,unlock方法.写写,写读互斥;读读不互斥,可以实现并发读的高效线程安全代码
4.容器类
BlockingQueue
阻塞队列,该类java.util.concurrent包下的重要类,通过对queue的学习可以得知,这个queue是单向队列,可以在队列头添加元素和在队尾删除或去除元素,类似于一个管道,特别适用于先进先出策略的一些应用场景.在队列的基础上添加了多线程协作的功能,put会在队列满的时候阻塞,直到有空间时被唤醒;take在队列空的时候阻塞,直到有东西拿的时候才被唤醒.用于生产者-消费者模型
常见的阻塞队列
ArrayListBlockingQueue
LinkedListBlockingQueue
DelayQueue
SynchronousQueue
ConcurrentHashMap
高效的线程安全哈希map,通过分段锁实现高效的存取
5.管理类
用于管理线程,本身不是多线程,常见的管理类有:ThreadPoolExecutor, ExecutorService
// 创建数组型缓冲等待队列
BlockingQueue bq = new ArrayBlockingQueue(10);
// ThreadPoolExecutor:创建自定义线程池,池中保存的线程数为3,允许最大的线程数为6
ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);
// 创建任务
Runnable t1 = new TempThread();
//然后运行
tpe.execute(t1)
// 关闭自定义线程池
tpe.shutdown();
ThreadPoolExecutor构造器参数含义:
corePoolSize:池内线程初始值与最小值,就算是空闲状态,也会保持该数量线程
maximumPoolSize:线程最大值,线程的增长始终不会超过该值。
keepAliveTime:当池内线程数高于corePoolSize时,经过多少时间多余的空闲线程才会被回收.回收前处于wait状态
unit:时间单位,可以使用TimeUnit的实例,如TimeUnit.MILLISECONDS
workQueue:待入任务(Runnable)的等待场所,该参数主要影响调度策略,如公平与否,是否产生饿死(starving)
threadFactory:线程工厂类,有默认实现,如果有自定义的需要则需要自己实现ThreadFactory接口并作为参数传入。
6.总结
这一章节主要讲解多线程的一些相关知识,结合JAVA内存模块(JMM)对其运行机制有了整体的了解,知道了JAVA中如何使用多线程编程,如何避免并发安全问题