java 键盘 线程,JAVA多线程详解

1.前言

在JAVA内存模型(JMM)中已经讲解了为了提高处理器的效率,实现"高并发"的效果,在处理器和存储设备之间加入高速缓存来作为缓冲.因此,使用多线程可以更好的利用cpu资源.

2.目录

e46f62482e27

目录

3.多线程

3.1.相关概念

进程:是程序一次执行过程,是系统运行程序的基本单位.系统运行一个程序即是一个进程从创建,运行到消亡的过程.一个进程就是一个执行中的程序,每个进程占有系统资源(如cpu时间,内存空间,文件,输入输出设备的使用权等).程序执行时,将被载入操作系统载入内存中

线程:线程是比进程更小的执行单位.一个进程在执行的过程中可以产生多个线程,多个线程共享同一块内存空间和一组系统资源.因此系统在创建线程,切换线程,负担比进程小得多,被称作轻量级进程

多线程:在同一时间点,运行多个线程(一个处理器在某一个时间点上永远都只能是一个线程,即使这个处理器是多核的,除非有多个处理器才能实现多个线程同时运行).这里的同一时间点实际上一个线程执行一会然后其他线程再执行

并行:当有多个线程在操作时,如果只有一个cpu,cpu将运行时间划分成若干个时间段,再讲时间段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状态

并发:当一个cpu执行一个线程时,另一个cpu可以执行另一个线程,两个线程互不抢占cpu资源,可以同时进行

3.2.线程状态

e46f62482e27

线程状态

调用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中如何使用多线程编程,如何避免并发安全问题

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值