多线程

基本概念：程序、进程、线程

程序

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。

进程

进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期

线程

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个进程同一时间并行执行多个线程，就是支持多线程的 。

线程的创建和使用

Thread类

Thread中的常用方法：

• 1. start():启动当前线程；调用当前线程的run()
• 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
• 3. currentThread():静态方法，返回执行当前代码的线程
• 4. getName():获取当前线程的名字
• 5. setName():设置当前线程的名字
• 6. yield():释放当前cpu的执行权
• 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
• 8. stop():已过时。当执行此方法时，强制结束当前线程。
• 9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
• 10. isAlive():判断当前线程是否存活

多线程的创建

方式一：继承于Thread类

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过此对象调用start()

//创建一个继承于Thread类的子类
class MyThread extends Thread{
    public MyThread(){
        super();
    }

    //重写Thread类的run() --> 将此线程执行的操作声明在run()中
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println("子线程： + i");
        }
    }
}


public class TestThread {
    public static void main(String[] args) {
        //创建Thread类的子类的对象
        MyThread mt = new MyThread();

        //通过此对象调用start()
        mt.start();
    }
}

方式二：实现Runnale接口

1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()

/创建一个实现了Runnable接口的类
class MyThread implements Runnable{

    //实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("子线程： + i");
        }
    }
}
public class TestThread {
    public static void main(String[] args) {

        //创建实现类的对象
        MyThread mt = new MyThread();

        //将此对象作为参数传递到Thread类的构造器中，创建`Thread类的对象
        Thread t = new Thread(mt);

        //通过Thread类的对象调用start()
        t.start();
    }
}

线程的优先级

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 -->默认优先级

2.如何获取和设置当前线程的优先级：
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级

说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

线程的生命周期

线程的同步（同步机制）

方式一：同步代码块

synchronized(同步监视器){
	//需要被同步的代码
}

说明：
1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

synchronized的锁是什么？
任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
同步方法的锁：静态方法（类名.class）、非静态方法（this）
同步代码块：自己指定，很多时候也是指定为this或类名.class
要求：多个线程必须要共用同一把锁。

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

public synchronized void show (String name){
	 …. 
}

1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2. 非静态的同步方法，同步监视器是：this
   静态的同步方法，同步监视器是：当前类本身

在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

Lock（锁）

ReentrantLock 类实现了 Lock ，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

	//1.实例化ReentrantLock
	private ReentrantLock loock = new ReentrantLock(true);
	 
	//2.调用锁定方法lock()
	lock.lock();

	//3.调用解锁方法umlock()
	lock.unlock();

线程的死锁问题

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃 自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于 阻塞状态，无法继续

解决方法

专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步

synchronized 与 Lock 的对比

1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。
2. Lock只有代码块锁，synchronized有代码块锁和方法锁
3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序： Lock --> 同步代码块（已经进入了方法体，分配了相应资源） --> 同步方法 （在方法体之外）

线程的通信

wait() 与 notify() 和 notifyAll()

wait()

一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

1. 在当前线程中调用方法： 对象名.wait()
2. 使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
3. 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
4. 调用此方法后，当前线程将释放对象监控权 ，然后进入等待
5. 在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()

一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。

1. 在当前线程中调用方法： 对象名.notify()
2. 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

notifyAll()

一旦执行此方法，就会唤醒所有被wait的线程。

1. 在当前线程中调用方法： 对象名.notifyAll()
2. 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

• 说明：
• 1. wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
• 2. wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常。
• 3. wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

面试题：sleep() 和 wait()的异同

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

不同点：

1. 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
2. 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
3. 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

JDK5.0新增线程创建方式

新增方式一：实现Callable接口

与使用Runnable相比， Callable功能更强大些

1. 相比run()方法，可以有返回值
2. 方法可以抛出异常
3. 支持泛型的返回值
4. 需要借助FutureTask类，比如获取返回结果

使用：

1. 创建一个实现Callable的实现类
2. 实现call方法，将此线程需要执行的操作声明在call()中
3. 创建Callable接口实现类的对象
4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6. 获取Callable中call方法的返回值

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

//1.创建一个实现Callable的实现类
class NumThread implements Callable {

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    public Object call() throws Exception{
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class CallableTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();

        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch(ExecutionException e){
            e.printStackTrace();
        }
    }
}

新增方式二：使用线程池

• 好处：
• 1.提高响应速度（减少了创建新线程的时间）
• 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
• 3.便于线程管理

•  corePoolSize：核心池的大小
  

•  maximumPoolSize：最大线程数
  

•  keepAliveTime：线程没有任务时最多保持多长时间后会终止