JAVA多线程详解

2020-06-10  本文已影响0人  只会敲代码的键盘手

1.前言

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

2.目录

目录

3.多线程

3.1.相关概念

3.2.线程状态

线程状态

3.3.同步机制

3.4.线程基本类

new Thread(){
    @Override
    public void run() {
        super.run();
        System.out.println("Thread重写run方法开启一个线程");
    }
}.start();

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("构造器传入runnable开启一个线程");
    }
}).start();

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        MyCallable myCallable = new MyCallable();
        Future<String> 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<String> stringFutureTask = new FutureTask<>(myCallableThread);
        new Thread(stringFutureTask).start();
    }
    static class MyCallable implements Callable<String> {
        @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<String> 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

//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隐患

  • ABA问题,A改为B,又改为A,检测符合预期,实际发生了变化,解决方案就是追加版本号,JDK的Atomic包提供了类AtomicStampedReference,使用compareAndSet方法先检测当前引用是否等于预期引用,再判断当前标志是否等于预期标志
  • 循环时间开销太大
    当某一线程每次获取的值都被其他线程修改了,那么它会一直进行自旋比较,直到成功为止,cpu开销十分大
3.5.3.Lock类

lock:在java.util.concurrent包内

ReentrantLock
ReentrantReadWriteLock.ReadLock
ReentrantReadWriteLock.WriteLock

主要目的是和synchronized一样,两者都是为了解决同步的问题,处理资源争端而产生的技术.功能类似但有一些区别

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<Runnable> bq = new ArrayBlockingQueue<Runnable>(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中如何使用多线程编程,如何避免并发安全问题

参考:https://www.cnblogs.com/wxd0108/p/5479442.html

上一篇 下一篇

猜你喜欢

热点阅读