【JavaSE】八、多线程

基本概念

程序（program）

为了完成特定的任务，用某种语言编写一组指令的集合。是一段静态的代码，静态的对象。

进程（Process）

程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程。有其产生、存在、消亡的过程【生命周期】

线程（Thread）

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

• 一个进程同一时间并行多个线程，就是执行多线程的
• 线程作为调度和执行的单位，每个线程有用独立的运行栈和程序计数器(pc)，线程切换的开销小
• 一个进程中的多个线程共享相同的内存单元/内存地址空间→从同一堆中分配对象，可以访问相同的变量和对象。使线程间通信更简便和搞笑。但多个线程操作共享的系统资源可能会带来安全隐患
• 分类
  • 守护线程
    • 用来服务用户线程的，通过在start()方法前调用。
    • thread.setDaemon(true)可以把一个用户线程变成一个守护线程
    • Java垃圾回收就是一个典型的守护线程
    • 若JVM中都是守护线程，当前JVM将退出
  • 用户线程

单核CPU和多核CPU

单核是一种假的多线程，同一个时间单元内只能执行一个线程的任务，但是因为CPU时间单元极短（切换很快），感觉不出来。

多核才能更好的发挥多线程的效率。

一个Java应用程序java.exe至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。

并行与并发

并行：多个CPU同时执行多个任务

并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。

多线程的优点

• 提高应用程序的响应
• 提高计算机系统CPU的利用率
• 改善程序结构。将长而复杂的进程分为多个线程独立运行易于理解和修改

线程的创建与使用

方式一：继承于Thread类

1.继承于Thread类

2.重写Thread类的run()

3.创建Thread类子类的对象

4.通过此对象调用start()

启动当前线程

调用当前线程的run()

方式二：实现Runnable接口

1.创建一个实现Runnable接口的类

2.重写Runnable接口的run()

3.创建实现类的对象

4.将此对象传入Thread类的构造器中，创建Thread类的对象

5.通过Thread类的对象调用start()

新增方式一：实现Callable接口【JKD5.0新增】

• 与使用Runnable接口相比，功能更强大
• 相比run()，可以有返回值
• 方法可抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，比如获取返回结果

Future接口：

• 可以对具体Runnable、callable任务的执行结果进行取消、查询是否完成、获取结果等、
• FutureTask是Future接口的唯一实现类
• FutureTask同时实现了Runnable，Future接口，既可作为Runnable被线程执行，又可作为Future得到Callable的返回值

1.创建一个实现Callable的实现类

2.实现call()，将此线程需要执行的操作声明在call()中

3.创建Callable接口实现类的对象

4.将此Callable接口实现类的对象作为参数传到FutureTask构造器中，创建FutureTask的对象

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

6.获取Callable中call方法的返回值

public class CallableThreadTest {
    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()
        Thread t=new Thread(futureTask);
        t.start();
        try {
						//6.获取Callable中call方法的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}
//1.创建一个实现Callable的实现类
class NumThread implements Callable{

    @Override
		//2.实现call()，将此线程需要执行的操作声明在call()中
    public Object call(){
        int sum=0;
        for (int i = 1; i <=100 ; i++) {
            if(i%2==0){
                sum+=i;
            }
        }
        return sum;
    }
}

新增方式二：使用线程池

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

可以提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中。避免频繁创建销毁、实现重复利用

• 提高响应速度（减少创建新线程的时间）
• 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
• 便于线程管理
  • corePoolSize：核心池大小
  • maximumPoolSize：最大线程数
  • keepAliveTime：线程没任务时最多保持多长时间后终止

线程池API：

• ExecutorService：

  真正的线程池接口，常见子类ThreadPoolExecutor

  • void execute(Runnable command)：

    执行任务/命令，一般用来执行Runnable

  • Future submit(Callable Task)：

    执行任务，一般用来执行Callable

  • void shutdown()：

    关闭连接池

• Executors：

  工具类、线程池的工厂类，用于创建并返回不同类型的线程池

  • Executors.newCachedThreadPool()：

    创建一个可根据需要创建新线程的线程池

  • Executors.newFixedThreadPool(n)：

    创建一个可重用固定线程数的线程池

  • Executors.newSingleThreadExecutor()：

    创建一个只有一个线程的线程池

  • Executors.newScheduledThreadPool(n)：

    创建一个线程池，可安排在给定延迟后运行命令或定期地执行

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行指定线程的操作，需提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumThread());//适用于Runnable
        //service.submit();//适用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}
class NumThread implements Runnable{

    @Override
    public void run() {
        for (int i = 1 ; i <=100 ; i++) {
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}

Thread类的常用方法

void start()：启动线程，并执行对象的run()

run()：线程在被调度时执行的操作

static Thread currentThread()：返回执行当前代码的线程

通常用于主线程和Runnable实现类

static void yield()：释放当前CPU的执行权

暂停当前执行线程，把执行机会让给优先级相同or更高的线程

若队列中没有同优先级的线程，忽略此方法

join()：当某个程序执行流中调用其他线程的join()时，调用线程会被阻塞，直到join()方法加入的join线程执行完为止【插队】

static void sleep(long millis)：（指定时间：毫秒）

令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重新排队

抛出InterruptedException异常

boolean isAlive()：判断线程是否还存活

优先级

低优先级获得调度的概率低，并非一定在高优先级线程后被调用

MAX_PRIORITY:10

NORM_PRIORITY:5

MIN_PRIORITY:1

getPriority()：返回线程优先值

setPriority(int newPrioriy)：设置线程优先级

线程的生命周期

一个完整的生命周期有五个状态

• 新建

  当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

• 就绪

  处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没分配到CPU资源

• 运行

  当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()定义了线程操作和功能

• 阻塞

  在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态

• 死亡

  线程完成了他的全部工作或被提前强制性地中止或出现异常导致结束

线程的同步

多个线程执行的不确定性引起执行结果的不稳定【共享的数据：临界资源】

• 例：三个窗口卖票，总票数100
  • 问题：卖票过程中出现重票、错票—>线程安全问题
  • 原因：某个线程操作车票过程中，尚未操作完成时，其他线程参与，也操作车票
  • 解决：当线程a在操作ticket的时候，其他线程不能参与，直到线程a操作完ticket后，其他线程才能操作ticket【即使线程a出现阻塞也不能被改变】
• 同步的方式
  • 优：解决了线程的安全问题
  • 劣：操作同步代码时，只能有一个线程参与，其他线程等待，相当于单线程的过程，效率慢

方式一：synchronized同步代码块

同步监视器：锁。任何一个类的对象都能被充当锁

要求：多个线程必须要共用同一把锁

实现Runnable接口的方式中可以使用this充当锁

继承Thread类的方式中可以使用当前类【类名.class】充当锁

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

方式二：synchronized同步方法

若操作共享数据的代码完整的声明在一个方法中，可用synchronized修饰此方法，将其同步。

此时该方法的同步监视器是this

public synchronized void sellTicket(){
        if(ticket>0){
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖出了一张票，票号为"+ticket);
            ticket--;
        }
        else {
            return;
        }
    }

继承Thread的线程使用该方式进行同步时，需将方法设为静态，因为此时同步监视器的this指的是该【类名.class】

方式三：Lock（锁）【JDK5新增】

显示定义同步锁对象来实现同步

java.util.concurrent.locks.Lock接口是对控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源前应先获得Lock对象。

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

class Window implements Runnable{
    private int tickets=100;
    //1.创建锁
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                //2.调用锁定方法lock()
                lock.lock();
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName()+"卖出票："+tickets);
                    tickets--;
                }
                else {
                    break;
                }
            }finally {
                //3.调用解锁方法unlock()
                lock.unlock();
            }
        }
    }
}

同步方法对比

• Lock是显式锁（手动开关锁），synchronized是隐式锁
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 用Lock锁，JVM将花费较少的时间调度线程，性能更好，且具有更好的拓展性
• 优先使用顺序
  • Lock
  • 同步代码块（已经进入了方法体，分配了相应资源）
  • 同步方法

死锁

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

出现死锁后不会出现异常或提示，所有线程阻塞，无法继续

解决方法

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

线程的通信

三个方法定义在java.lang.Object中

wait()：当前线程进入阻塞状态，并释放同步监视器

notify()：唤醒被wait的一个线程。若有多个 线程被wait，就唤醒优先级最高的线程

notifyAll()：唤醒所有被wait()的线程

必须使用在同步方法块或同步方法中。

以上方法的调用者必须是同步代码块或同步方法中的同步监视器

sleep和wait的异同

• 同：
  • 都可以使当前线程进入阻塞状态
• 异：
  • Thread类中声明sleep()，Object类中声明wait()
  • 可在任何场景调用sleep()，必须在在同步方法块或同步方法中调用wait()
  • 若两个方法都使用在同步方法快或同步方法中，sleep()不会释放锁，wait()会释放锁