Java——多线程

public class TreadDemo{
    public static void main(String[] args) {
        // 3、new一个新线程对象
        Thread t = new MyThread();
        //4、调用start方法启动线程（执行的还是run方法)lrt.start();
        t.start();
        
        for(int i = 0; i < 5 ; i++) {
            System.out.println("主线程执行输出:" + i);
        }
    }


}
//1.定义一个线程类继承Tread类
class MyThread extends Thread{

    //2、重写run方法，里面是定义线程以后要干啥
    @Override
    public void run() {
        for (int i = 0; i< 5; i++) {
            System.out.println("子线程执行输出:" + i);
        }
    }
 }

两个线程执行顺序不一定（并行执行）

②方式二：实现Runnable接口

1.定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

2.创建MyRunnable任务对象

3.把MyRunnable任务对象交给Thread处理。

4.调用线程对象的start()方法启动线程

Thread的构造器

构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )	封装Runnable对象成为线程对象，并指定线程名称

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

public class TreadDemo{
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        //4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5.启动线程
        t.start();

        for (int i = 0; i< 5; i++) {
            System.out.println("主线程执行输出:" + i);
        }
    }


}
//1.定义一个线程类继承Tread类
class MyRunnable implements Runnable{

    //2、重写run方法，里面是定义线程以后要干啥
    @Override
    public void run() {
        for (int i = 0; i< 5; i++) {
            System.out.println("子线程执行输出:" + i);
        }
    }
 }

③方式三：实现Callable/FutureTask接口

1.得到任务对象

①定义类实现Callable接口，重写call方法，封装要做的事情。

②用FutureTask把Callable对象封装成线程任务对象。

2.把线程任务对象交给Thread处理。

3.调用Thread的start方法启动线程，执行任务

4.线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果。

FutureTask的API

方法名称	说明
public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象。
public V get() throws Exception	获取线程执行call方法返回的结果。

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

可以在线程执行完毕后去获取线程执行的结果。

缺点：编码复杂一点。

import java.util.*;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;


public class TreadDemo{
    public static void main(String[] args) {
        //3.创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        //4.把Callable任务对象交给FutureTask对象
        //FutureTask对象作用1：是Runnable的对象（实现Runnable接口），可以交给Thread了
        //FutureTask对象作用2：可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5.交给线程处理
        Thread t1 = new Thread(f1);
        //6.启动线程
        t1.start();

        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            //如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果
            String rs1 = f1.get();
            System.out.println("第一个结果："+ rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 = f2.get();
            System.out.println("第一个结果："+ rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}
//1.定义一个线程类继承Tread类
class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    //2、重写call方法（任务方法)
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "子线程执行的结果是:" +sum;
    }
}

④方式四：自定义线程池

ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 5, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

然后可以使用pool的executor方法执行Runnable任务，或者使用submit方法执行Callable任务，然后同样用Future接受返回值。

⑤方式五：使用Executors创建线程池

详细可以参考下面的 七、线程池

示例：ExecutorService executorService = Executors.newFixedThreadPool(8);

executorService同样有executor方法和submit方法，同样使用即可

三、Thread常用方法

Thread常用方法：

获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()。

方法名称	说明
String getName()	获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name)	将此线程的名称更改为指定的名称，通过构造器也可以设置线程名称
public static Thread currentThread()：	返回对当前正在执行的线程对象的引用
public static void sleep(long time)	让当前线程休眠指定的时间后再继续执行，单位为毫秒。

Thread的构造器

方法名称	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )	封装Runnable对象成为线程对象，并指定线程名称

四、线程安全

多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

线程安全问题出现的原因

存在多线程并发

同时访问共享资源

存在修改共享资源

五、线程同步

让多个线程实现先后依次访问共享资源，这样就解决了安全问题

方式一：同步代码块

作用：把出现线程安全问题的核心代码给上锁。

原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

synchronized(同步锁对象) {
	操作共享资源的代码(核心代码)
}

锁对象要求

理论上：锁对象只要对于当前同时执行的线程来说是同一个对象即可。

（故有时候使用常量，因为常量是唯一的，就能限制锁对象唯一）

锁对象的规范要求

规范上：建议使用共享资源作为锁对象。

对于实例方法建议使用this作为锁对象。

对于静态方法建议使用字节码（类名.class）对象作为锁对象。

方式二：同步方法

作用：把出现线程安全问题的核心方法给上锁。

原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

修饰符 synchronized 返回值类型 方法名称(形参列表) {
	操作共享资源的代码
}

同步方法底层原理

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！

如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

方式三：Lock锁

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

方法名称	说明
public ReentrantLock()	获得Lock锁的实现类对象
void lock()	获得锁
void unlock()	释放锁

方式四：volatile关键字

保证了不同线程之间对共享变量操作的可见性
每个线程都能从主内存中获取volitail修饰的属性，并缓存在本地工作内存中
一旦有线程修改了该值，会自动刷新到主内存中，同时其他内存中的该值失效，再次访问需要重新到主内存中获取

禁止对指令进行重排序操作
保证该指令前的所有指令都执行，该指令后的所有指令都未执行

六、线程通信

1.概念

线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

线程通信常见形式

通过共享一个数据的方式实现。

根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

线程通信实际应用场景

生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。

要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

2.Object类的等待和唤醒方法

方法名称	说明
void wait()	让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒正在等待的所有线程

七、线程池

1.概念

线程池就是一个可以复用线程的技术。

不使用线程池的问题

如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

2.线程池API

得到线程池对象

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

ThreadPoolExecutor构造器的参数说明

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

参数一：指定线程池的线程数量（核心线程）： corePoolSize 不能小于0

参数二：指定线程池可支持的最大线程数： maximumPoolSize 最大数量 >= 核心线程数量

参数三：指定临时线程的最大存活时间： keepAliveTime 不能小于0

参数四：指定存活时间的单位(秒、分、时、天)： unit 时间单位

参数五：指定任务队列： workQueue 不能为null

参数六：指定用哪个线程工厂创建线程： threadFactory 不能为null

参数七：指定线程忙，任务满的时候，新任务来了怎么办： handler 不能为null

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，会创建临时线程。

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候会开始任务拒绝。

方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

方法名称	说明
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉。
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor ()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

方法名称	存在问题
public static ExecutorService newFixedThreadPool(int nThreads)	允许请求的任务队列长度是Integer.MAX_VALUE，可能出现OOM错误（ java.lang.OutOfMemoryError ）
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newCachedThreadPool()	创建的线程数量最大上限是Integer.MAX_VALUE，线程数可能会随着任务1:1增长，也可能出现OOM错误（ java.lang.OutOfMemoryError ）
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

3.线程池处理Runnable/Callable任务

ExecutorService的常用方法

方法名称	说明
void execute(Runnable command)	执行任务/命令，没有返回值，一般用来执行 Runnable 任务
Future<T> submit(Callable<T> task)	执行任务，返回未来任务对象获取线程结果，一般拿来执行 Callable 任务
void shutdown()	等任务执行完毕后关闭线程池
List<Runnable> shutdownNow()	立刻关闭，停止正在执行的任务，并返回队列中未执行的任务

新任务拒绝策略

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy：	丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的run()方法从而绕过线程池直接执行

补充知识：定时器

定时器是一种控制任务延时调用，或者周期调用的技术。

作用：闹钟、定时邮件发送。

定时器的实现方式

方式一：Timer

构造器	说明
public Timer()	创建Timer定时器对象

方法	说明
public void schedule(TimerTask task, long delay, long period)	开启一个定时器，按照计划处理TimerTask任务

Timer定时器的特点和存在的问题

1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。

2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。

方式二： ScheduledExecutorService

Executors的方法	说明
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	得到线程池对象

ScheduledExecutorService的方法

说明

public ScheduledFuture<?>

scheduleAtFixedRate(Runnable command,

long initialDelay,

long period,

TimeUnit unit)

周期调度方法

ScheduledExecutorService的优点

基于线程池，某个任务的执行情况不会影响其他定时任务的执行。

补充知识：并发、并行

正在运行的程序（软件）就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的。

补充知识：线程的生命周期

线程的状态

线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。

线程状态	描述
NEW(新建)	线程刚被创建，但是并未启动。
Runnable(可运行)	线程已经调用了start()等待CPU调度
Blocked(锁阻塞)	线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态；。
Waiting(无限等待)	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

补充知识：锁

偏向锁轻量级锁重量级锁

偏向锁：默认情况下一个对象支持偏向锁，对象的对象头有一个bit用于保存偏向锁的状态。在第一次获取的时候，该对象处于无锁状态，然后就将该线程ID存到对象头中的对应位置，同时会生成一个LockRecord存在该线程的栈中，其中的Owner指向当前线程；而解锁操作就是将LockRecord中的Owner置为空，代表代码块都执行完成了。当其他线程尝试去获取这个锁时，会判断是否还在执行，如果没执行，直接替换线程ID即可
轻量级锁：当偏向锁遇到锁竞争时，就会升级为轻量级锁，并设置偏向位为不可偏向。轻量级锁采用自旋的方式获取锁，适用于锁竞争不激烈并且短时间持有锁的情况。
重量级锁：在轻量级锁遇到多个线程竞争的时候，就会升级为重量级锁，未或许到的锁会进入阻塞态，等待锁的释放。

AQS

AQS ( Abstract Queued Synchronizer ）是一个抽象的队列同步器，通过维护一个共享资源状态（ Volatile Int State ）和一个先进先出（ FIFO ）的线程等待队列来实现一个多线程访问共享资源的同步框架。

原理：
AQS 为每个共享资源都设置一个共享资源锁，线程在需要访问共享资源时首先需要获取共享资源锁，如果获取到了共享资源锁，便可以在当前线程中使用该共享资源，如果获取不到，则将该线程放入线程等待队列（**先进先出**），等待下一次资源调度

使用：
在使用AQS创建自定义锁时，AQS一般是被**内部类**去继承实现的。需要去重写几个方法：`tryAcquire(int)`，`tryRelease(int)`，`tryAcquireShared(int)`，`tryReleaseShared(int)`，`isHeldExclusively()`（最后一个方法一般在需要使用condition时才需要重写，即当某线程需要放到条件队列中，遇到某条件才唤醒时使用）
在使用时可以在`tryAcquire(int)`和`tryRelease(int)`中使用`getState()`,`setState(int)`,`compareAndSetState(int,int)`去获取和改变AQS的状态码，AQS的状态码默认情况下是：0代表锁可用，1代表锁被占有；使用setExclusiveOwnerThread()设置独占资源的线程；因此可以在`tryAcquire(int)`获取状态码，为0的情况下置为1，并返回true，在`tryRelease(int)`将状态码置为0，完成锁的释放。在继承AQS类并重写完这些方法后，就可以调用其本身的acquire和release方法获取和释放锁了。

CAS如何实现

CAS：CompareAndSwep，其中包括几个参数：①对象本身②值的内存偏移地址③期望更新的值(旧值)④更新的值(新值)，只有当目前的值和期望更新的值相同时，才会去完成更新操作，否则会自旋或者不操作。
但作为乐观锁，可能会遇到ABA问题，可用版本号和时间戳来解决

共享锁

mysql的行锁中的读锁即是共享锁。即：多个线程如果都对某一行数据发起读请求，就会尝试获取该行数据的共享锁，可由多个线程或事务获取到该共享锁，即读操作可同时发生。
与此相对的就是排他锁/互斥锁，一旦获取了一行数据的排他锁/互斥锁，其他事务或线程就不能获取该数据的任何锁；并且如某行数据被获取了共享锁，也不能再被获取排他锁/互斥锁。
读可共享-读写不共享-写写不共享

分布式锁

分布式锁用于解决分布式系统中控制共享资源的访问

Redis的分布式锁：
1. 使用setnx添加锁（setnx保证原子性，且只有在key不存在时才能成功，即多个系统并发获取锁，也只有一个系统能成功获取到锁）`set <lock.key> <lock.value> nx ex <expireTime>`同时用ex能设置过期时间
2. 可使用del主动释放锁，即直接删除该键值对
3. 可重入锁的实现方式：hash类型设置可重入锁，`HSETNX`，然后通过获取其中的字段判断是否可重入，并且能够设置重入的次数。
4. 使用Redission的看门狗机制或者自定义守护线程维护获取锁的业务的锁过期时间

ReentrantLock和Synchronized

	ReentrantLock	Synchronized
锁实现机制	依赖AQS	监视器模式
灵活性	支持响应中断、超时、尝试获取锁	不灵活
释放形式	必须显式调用unlock()	自动释放监视器
锁类型	公平锁&非公平锁	非公平锁
条件队列	可关联多个条件队列	关联一个条件队列
可重入性	可重入	可重入