Java必会之多线程


一、线程的基本知识

1.1 线程知识

进程和线程的关系和区别

线程:

线程是进程的基本执行单元,进程想要执行任务,必须要有线程。程序启动默认开启一条线程,这个线程被称为主线程。

进程:

进程是指在系统中正在运行的一个应用程序。每个进程之间是独立的,每个进程均运行在其专用且受保护的内存里。

线程的六个状态:

NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED

Thread流程图:

Thread的方法:

方法说明
void join()t.join() 当前线程调用其他线程的t.join()方法,当前线程进入等待状态,当前线程不会释放已经持有的锁。线程t执行完毕后,当前线程进入就绪状态。
static native void sleep()静态方法,线程睡眠,并让出CPU时间片
void wait()当前线程调用对象的wait()方法,当前线程释放对象锁,进入等待队列。依靠notify()/notifyAll()唤醒。
native void notify()唤醒在此对象监视器上等待的单个线程,选择是任意性的。
native void notifyAll()发送信号通知所有等待线程

1.2 线程安全

并发的相关性质:

  • 原子性:原子操作。对基本数据类型的读取和赋值操作是原子性操作,即这些操作是不可被中断的,要么执行,要么不执行。

  • 可见性:对于可见性,java提供了volatile关键字来保证可见性。

    当一个共享变量被volatile修饰时,他会保证修改的值会立即被更新到主存,当有其他线程需要读取时,他会去主存中读取新值。

    volatile 不保证原子性。

  • 有序性:Java允许编译器和处理器对指令重排序,但是重排序不会影响到单线程的执行,却会影响到多线程并发执行的正确性。

synchronized

使用对象头标记字实现

使用场景:

  • 修饰方法:
    一个对象中的加锁方法只允许一个线程访问。
  • 修饰静态方法:
    由于静态方法是类方法,所以多个线程不同对象访问这个静态方法,也是可以保证同步的。
  • 修饰代码块:
    如:synchronized(obj){...} 这里的obj可以是类中的一个属性,也可以是对象,这时他跟修饰普通方法一样,如果obj是Object.class这样的,那么效果跟修饰静态方法类似。

volatile

  1. 每次读取都强制从主内存刷数据
  2. 适用场景:单个线程写,多个线程读
  3. 原则:能不用就不用,不确定的时候也不用
  4. 语义
  • 可见性
  • 禁止指令重排序(不完全保证有序性)
  • 不能保证原子性。

为什么不保证有序性呢?举个例子说明

上述代码,语句1和2,不会被重排到3的后面,4和5也不会到3的前面。但是1和2的顺序、4和5的顺序无法保证。

final

final定义类型说明
final class XXX不允许继承
final 方法不允许Override
final 局部变量不允许修改
final 实例属性构造函数、初始化块后不能变更。只能赋值一次。构造函数结束返回时,final域最新的值保证对其他线程可见。
final static 属性静态块执行后不允许变更,只能赋值一次

二、线程池

  1. Executor :执行者 -顶层接口
  2. ExecutorService :继承于Executor,线程池的接口API
  3. ThreadFactory:线程工才
  4. Executors:工具类

submit方法和execute方法的区别:

  • submit方法:有返回值,用Future封装,执行的方法异常了可以在主线程里catch到。
  • execute方法:无返回值,方法执行异常是捕捉不到的

如下图:

ExecutorService主要方法:

构造线程池的参数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corePoolSize :核心线程数
maximumPoolSize:最大线程数
keepAliveTime:当线程数超过了核心线程数,空闲线程需要等待多久等待不到新任务就终止。
workQueue:任务队列
threadFactory:线程工厂
handler:拒绝策略

提交任务逻辑:

  1. 判断核心线程数
  2. 加入workQueue
  3. 判断最大线程数,没达到就创建
  4. 执行拒绝策略(默认是抛异常)

缓冲队列

  1. ArrayBlockingQueue:规定大小的BlockingQueue,构造时必须指定大小
  2. LinkedBlockingQueue:大小不固定的BlockingQueue,如果构造时指定大小,则有大小限制,不指定大小,则用Integer.MAX_VALUE来决定
  3. PriorityBlockingQueue:类似于LinkedBlockingQueue,不同在它根据对象的自然顺序或者构造函数的Comparator进行排序,不是FIFO
  4. SynchronizedQueue:特殊的BlockingQueue,对其的操作必须是放和取交替完成。

拒绝策略:

  1. AbortPolicy:丢弃任务并抛异常
  2. DiscardPolicy:丢弃任务,不抛异常
  3. DiscardOldestPolicy:丢弃队列最前面的任务,重新提交被拒绝的任务
  4. CallerRunsPolicy:由提交任务的线程处理该任务。

线程工厂(ThreadFactory):

自定义示例:

public class CustomThreadFactory implements ThreadFactory {

    private AtomicInteger count=new AtomicInteger();

    @Override
    public Thread newThread(Runnable r) {
        Thread thread=new Thread(r);
        thread.setDaemon(false);
        thread.setName("customThread-"+count.getAndIncrement());
        return thread;
    }
}

线程工具类:

  1. newSingleThreadExecutor

    创建一个单线程的线程池。如果这个线程因为异常结束,那么会有一个新的线程替代它。此线程池保证所有的任务的执行顺序按任务提交顺序执行。

  2. newFixedThreadPool

    创建固定大小的线程池。缺点:队列使用的LinkedBlockingQueue,且没有限制大小。

  3. newCachedThreadPool

    创建一个可缓存的队列,如果线程池大小超过了处理任务需要的线程,那么就会回收部分空闲线程。缺点:此线程池不会对线程池大小做限制。

  4. newScheduledThreadPool

    创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

创建固定线程池的经验:

假设服务器核心数为N

  1. 如果是CPU密集型应用,则线程池大小设置为N或N+1
  2. 如果是IO密集型应用,则线程池大小设置为2N或2N+2

本站声明:网站内容来源于网络,如有侵权,请联系我们,我们将及时处理。

  • 分享:
评论
还没有评论
    发表评论 说点什么