Java多线程知识点总结

首先区分进程与线程的概念

进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
线程是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

线程与进程一定程度上来说是包含与被包含的关系。

同步与异步

同步：指不同线程在执行时排队执行，效率虽然低但是数据安全。
异步：指不同线程同时执行任务，效率高但是数据的安全性得不到保证。

并发与并行

并发：指两个或多个事件在同一个时间段内发生
并行：指两个或多个事件在同一时刻发生（强调同时发生）。

如何实现多线程？

Java实现多线程一共有四种方法：
1.继承Thread类，重写run方法；（其实Thread类本身也实现了Runnable接口）
2.继承Runnab接口，重写run方法；
3.实现Callable接口，重写call方法（有返回值）；
4.使用线程池（有返回值）

1.继承Thread类，重写run方法.
每次创建新的线程都需要新建一个Thread的子类对象。
启动线程需要调用start()方法，如
new Thread子类（）.start（）
创建线程实际调用的是父类Thread空参的构造器

class MyThread{
public static void main(String[] args){

    new ExtendsTHread().start();
    
 }
}

class ExtendsThread extends Thread{
  public void run(){
  System.out.println(Thread.currentThread().getName());
  }
}

2.实现Runnable接口，实现run方法
无论创建多少个线程，只需要创建一个Runnable接口实现类的对象
启动线程时格式为：new Thread（ Runnable接口实现类的对象）.start（）
创建线程调用的是Thread类Runable类型参数的构造器

public class MyThread {

    public static void main(String ards[]){
        Runnable implRunnable = new ImplRunnable();
        for(int i=0;i<10;i++){
            new Thread(implRunnable).start();
        }
        System.out.println(Thread.currentThread().getName());
    }
    
}

class ImplRunnable implements Runnable{
    private volatile  int i = 0;
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+ i++);
        
    }
}

3.实现Callable接口，重写call方法（有返回值）

自定义类实现Callable接口时，必须指定泛型，该泛型即返回值的类型

每次创建一个新的线程，都要创建一个新的Callable接口的实现类、

如何启动线程？

（1）创建一个Callable接口的实现类的对象

（2）创建一个FutureTask对象，传入Callable类型的参数

public FutureTask(Callable callable){……}

（3）调用Thread类重载的参数为Runnable的构造器创建Thread对象

将FutureTask作为参数传递

public class FutureTask implements RunnableFuture

public interface RunnableFuture extends Runnable, Future

如何获取返回值？

调用FutureTask类的get()方法

Runnable 与 Callable的相同点
都是接口
都可以编写多线程程序
都采用Thread.start()启动线程
Runnable 与 Callable的不同点
Runnable没有返回值；Callable可以返回执行结果
Callable接口的call()允许抛出异常；Runnable的run()不能抛出
Callable获取返回值
Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执
行，如果不调用不会阻塞。

接口定义 //Callable接口
public interface Callable {
V call() throws Exception;
}
//Runnable接口
public interface Runnable {
public abstract void run();
}

Callable使用步骤

1. 编写类实现Callable接口 , 实现call方法
   class XXX implements Callable {
   @Override
   public call() throws Exception {
   return T;
   }
   }
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象 FutureTask future = new FutureTask<>(callable);
3. 通过Thread,启动线程
   new Thread(future).start();

例如：

public class MyThread {

    public static void main(String ards[]) throws InterruptedException, ExecutionException{

        for(int i=0;i<10;i++){
            Callable<Integer> implCallable = new ImplCallable();
            FutureTask<Integer> futureTask = new FutureTask<Integer>(implCallable);
            new Thread(futureTask).start();
            System.out.println(Thread.currentThread().getName()+"----"+futureTask.get());
        }

        System.out.println(Thread.currentThread().getName());
    }
    
}

class ImplCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int result = 0;
        for(int i=0;i<10;i++){
            result += i;
        }
        System.out.println(Thread.currentThread().getName());
        return result;
    }

}

4.线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间.
线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处
1.降低资源消耗。
2.提高响应速度。
3.提高线程的可管理性

Java中一共有四种线程池

1. 缓存线程池

/**
* 缓存线程池.
* (长度无限制)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在,则创建线程 并放入线程池, 然后使用
*/
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中 加入 新的任务
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

2. 定长线程池

/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
3. 单线程线程池
4. 周期性任务定长线程池
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

3. 单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.
/**
* 单线程线程池.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

4. 周期性任务定长线程池

public static void main(String[] args) {
/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位
*/
/*service.schedule(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,TimeUnit.SECONDS);
*/
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,2,TimeUnit.SECONDS);
}

线程安全问题

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。即多个线程执行的不确定性引起执行结果的不稳定。
例如：火车票出售时，多个窗口同时售票，出现票数为负数的问题

解决办法
1.同步代码块

synchronized(obj)
{
    //需要被同步的代码块
}

其中，obj 称为同步监视器，也就是锁，原理是：当线程开始执行同步代码块前，必须先获得对同步代码块的锁定。并且任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。

2.同步方法

public synchronized void testThread()
{
    //需要被同步的代码块
}

对于关键字synchronized修饰的方法，不需要再指定同步监视器，这个同步方法（非static方法）无需显式地指定同步监视器，同步方法的同步监视器就是this，也就是调用该方法的对象。

注意，synchronized可以修饰方法，修饰代码块，但是不能修饰构造器、成员变量等。

3.同步锁

class A
{
    private final ReentrantLock lock=new ReentrantLock();
    public void method()
    {
        lock.lock();
        try{
                //需要被同步的代码块
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                lock.unlock();
        }
    }
}

这是一种功能更为强大的线程同步机制，通过显式定义同步锁对象来实现同步，这里的同步锁由Lock对象充当。使用Lock与使用同步代码块有点类似，只是使用Lock时可以显示使用Lock对象作为同步锁，而使用同步方法时系统隐式使用当前对象作为同步监视器。

其中，为了确保能够在必要的时候释放锁，代码中使用finally来确保锁的释放，来防止死锁！

死锁是什么？

死锁，是指多个线程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

死锁产生的4个必要条件？

产生死锁的必要条件：

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程–资源的环形链。

线程的六种状态

线程状态	解释
NEW	尚未启动的线程状态，即线程创建，还未调用start方法
RUNNABLE	就绪状态（调用start，等待调度）+正在运行
BLOCKED	等待监视器锁时，陷入阻塞状态
WAITING	等待状态的线程正在等待另一线程执行特定的操作（如notify）
TIMED_WAITING	具有指定等待时间的等待状态
TERMINATED	线程完成执行，终止状态

一、新建状态(NEW)
即用new关键字新建一个线程，这个线程就处于新建状态。

二、运行状态(RUNNABLE)
操作系统中的就绪和运行两种状态，在Java中统称为RUNNABLE。

就绪状态（READY)
当线程对象调用了start()方法之后，线程处于就绪状态，就绪意味着该线程可以执行，但具体啥时候执行将取决于JVM里线程调度器的调度。

不允许对一个线程多次使用start。

线程执行完成之后，不能试图用start将其唤醒。

其他状态如何转换为就绪状态？
线程调用start()，新建状态转化为就绪状态。
线程sleep(long)时间到，等待状态转化为就绪状态。
阻塞式IO操作结果返回，线程变为就绪状态。
其他线程调用join()方法，结束之后转化为就绪状态。
线程对象拿到对象锁之后，也会进入就绪状态。

运行状态(RUNNING)
处于就绪状态的线程获得了CPU之后，真正开始执行run()方法的线程执行体时，意味着该线程就已经处于运行状态。需要注意的是，对于单处理器，一个时刻只能有一个线程处于运行状态。
对于抢占式策略的系统来说，系统会给每个线程一小段时间处理各自的任务。时间用完之后，系统负责夺回线程占用的资源。下一段时间里，系统会根据一定规则，再次进行调度。

运行状态转变为就绪状态的情形：

线程失去处理器资源。线程不一定完整执行的，执行到一半，说不定就被别的线程抢走了。
调用yield()静态方法，暂时暂停当前线程，让系统的线程调度器重新调度一次，它自己完全有可能再次运行。

提示调度程序，当前线程愿意放弃当前对处理器的使用。这时，当前线程将会被置为就绪状态，和其他线程一样等待调度，这时候根据不同优先级决定的概率，当前线程完全有可能再次抢到处理器资源。

三、阻塞状态(BLOCKED)
阻塞状态表示线程正等待监视器锁，而陷入的状态。

以下场景线程将会阻塞：

1.线程等待进入synchronized同步方法。
2.线程等待进入synchronized同步代码块。

线程取得锁，就会从阻塞状态转变为就绪状态。

四、等待状态(WAITING)
进入该状态表示当前线程需要等待其他线程做出一些的特定的动作（通知或中断）。

运行->等待
当前线程运行过程中，其他线程调用join方法，当前线程将会进入等待状态。
当前线程对象调用wait()方法。
-LockSupport.park()：出于线程调度的目的禁用当前线程。

等待->就绪
等待的线程被其他线程对象唤醒，notify()和notifyAll()。
LockSupport.unpark(Thread)，与上面park方法对应，给出许可证，解除等待状态。

五、超时等待状态(TIMED_WAITING)
区别于WAITING，它可以在指定的时间自行返回。

运行->超时等待
调用静态方法，Thread.sleep(long)
线程对象调用wait(long)方法
其他线程调用指定时间的join(long)。
LockSupport.parkNanos()。
LockSupport.parkUntil()。
补充：
sleep和yield的不同之处：

sleep(long)方法会使线程转入超时等待状态，时间到了之后才会转入就绪状态。而yield()方法不会将线程转入等待，而是强制线程进入就绪状态。
使用sleep(long)方法需要处理异常，而yield()不用。
超时等待->就绪
同样的，等待的线程被其他线程对象唤醒，notify()和notifyAll()。
LockSupport.unpark(Thread)。

六、消亡状态
即线程的终止，表示线程已经执行完毕。前面已经说了，已经消亡的线程不能通过start再次唤醒。

run()和call()线程执行体中顺利执行完毕，线程正常终止。
线程抛出一个没有捕获的Exception或Error。
需要注意的是：主线成和子线程互不影响，子线程并不会因为主线程结束就结束。