JAVASE复习之多线程

1 多线程入门

1.1 多线程的创建方式

1.1.1 继承Thread方式

基本步骤：

• 创建一个类继承Thread类。
• 在类中重写run方法（线程执行的任务放在这里）
• 创建线程对象，调用线程的start方法开启线程。
• 执行程序，观察控制台的打印数据的现象

弊端：类只能单一继承

1.1.2 实现Runable方式

• 构造方法
  • public Thread(Runnable target)
  • public Thread(Runnalbe target , String name)
• 实现步骤
  • 定义任务类实现Runnable，并重写run方法
  • 创建任务对象
  • 使用含有Runnable参数的构造方法，创建线程对象并指定任务。
  • 调用线程的start方法，开启线程

创建任务类：

public class MyTask implements Runnable{
    //线程任务
    @Override
    public void run() {
        System.out.println("线程开始执行");
    }
}

启动线程：

        Thread t = new Thread(new MyTask());
        t.start();

1.2 Thread类中常用方法

• String getName()：返回此线程的名称
• void setName(String name)：将此线程的名称更改为等于参数 name
• public static Thread currentThread()：获取当前线程对象
• public static void sleep(long time)：让线程休眠指定的时间，单位为毫秒
• void join() 挂起其他线程，仅当前线程

2 线程安全

2.1 线程安全问题

• 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了

2.2 线程同步

• java允许多线程并发执行，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证该变量的唯一性和准确性
• 分类
  • 同步代码块
  • 同步方法
  • 锁机制。Lock

2.3 同步代码块

同步代码块 : 锁住多条语句操作共享数据，可以使用同步代码块实现

第一部分 : 格式
           synchronized(任意对象) {
                   多条语句操作共享数据的代码
           }
           
第二部分 : 注意
           1 默认情况锁是打开的，只要有一个线程进去执行代码了，锁就会关闭
           2 当线程执行完出来了，锁才会自动打开

第三部分 : 同步的好处和弊端
            好处 : 解决了多线程的数据安全问题
            弊端 : 当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低
            程序的运行效率

2.4 同步方法

同步方法：就是把synchronized关键字加到方法上

格式：修饰符 synchronized 返回值类型 方法名(方法参数) {    }

同步代码块和同步方法的区别:
    1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
    2 同步代码块可以指定锁对象,同步方法不能指定锁对象

注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。
    1 对于非static方法,同步锁就是this。
    2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。   Class类型的对象

2.5 Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题
但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁

Lock中提供了获得锁和释放锁的方法
    void lock()：获得锁
    void unlock()：释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
    ReentrantLock的构造方法
    ReentrantLock()：创建一个ReentrantLock的实例

注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用

2.6 线程的状态

3 线程通信

• 线程间的通讯技术就是通过等待和唤醒机制，来实现多个线程协同操作完成某一项任务 （多线程中，某个线程进入等待状态中，需要其线程唤醒他）例如经典的生产者和消费者案例。等待唤醒机制其实就是让线程进入等待状态或者让线程从等待状态中唤醒，需要用到两种方法，如下：
• 等待方法 :
  • void wait() 让线程进入无限等待。
  • void wait(long timeout) 让线程进入计时等待
  • 以上两个方法调用会导致当前线程释放掉锁资源。
• 唤醒方法 :
  • void notify() 唤醒处于等待状态的单个线程。
  • void notifyAll() 唤醒处于等待状态的所有线程。
  • 以上两个方法调用不会导致当前线程释放掉锁资源
• 注意
  • 等待和唤醒的方法，都要使用锁对象调用（需要在同步代码块中调用)
  • 等待和唤醒方法应该使用相同的锁对象调用

4 线程池

4.1 线程使用存在的问题

• 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
• 如果大量线程在执行，会涉及到线程间上下文的切换，会极大的消耗CPU运算资源

4.2 线程池的介绍以及使用

• 线程池其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

使用流程：

• 创建线程池指定线程开启的数量
• 提交任务给线程池，线程池中的线程就会获取任务，进行处理任务。
• 线程处理完任务，不会销毁，而是返回到线程池中，等待下一个任务执行。
• 如果线程池中的所有线程都被占用，提交的任务，只能等待线程池中的线程处理完当前任务

线程池的好处：

• 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
• 提高响应速度。当任务到达时，任务可以不需要等待线程创建 , 就能立即执行。
• 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存 (每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java提供好的线程池：

 java.util.concurrent.ExecutorService 是线程池接口类型。
 使用时我们不需自己实现，JDK已经帮我们实现好了
 
 获取线程池我们使用工具类java.util.concurrent.Executors的静态方法
  	 public static ExecutorService newFixedThreadPool (int num): 指定线程池最大线程池数量获取线程池
 线程池ExecutorService的相关方法
   	<T> Future<T>  submit(Callable<T> task) 
   	Future<?> submit(Runnable task)
 关闭线程池方法（一般不使用关闭方法，除非后期不用或者很长时间都不用，就可以关闭）
   void shutdown()  启动一次顺序关闭，执行以前提交的任务，但不接受新任务

4.3 线程池处理任务

4.3.1 线程池处理Runnable任务

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
    1 需求 :
        使用线程池模拟游泳教练教学生游泳。
        游泳馆（线程池）内有3名教练（线程）
        游泳馆招收了5名学员学习游泳（任务）。

    2 实现步骤：
        创建线程池指定3个线程
        定义学员类实现Runnable，
        创建学员对象给线程池
 */
public class Test1 {
    public static void main(String[] args) {
        // 创建指定线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(3);

        // 提交任务
        threadPool.submit(new Student("小花"));
        threadPool.submit(new Student("小红"));
        threadPool.submit(new Student("小明"));
        threadPool.submit(new Student("小亮"));
        threadPool.submit(new Student("小白"));

        threadPool.shutdown();// 关闭线程池
    }
}

class Student implements Runnable {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        String coach = Thread.currentThread().getName();
        System.out.println(coach + "正在教" + name + "游泳...");

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(coach + "教" + name + "游泳完毕.");
    }
}

4.3.2 线程池处理Callable任务

import java.util.concurrent.*;

/*
    需求: Callable任务处理使用步骤
        1 创建线程池
        2 定义Callable任务
        3 创建Callable任务，提交任务给线程池
        4 获取执行结果

    <T> Future<T> submit(Callable<T> task) : 提交Callable任务方法    
    返回值类型Future的作用就是为了获取任务执行的结果。
    Future是一个接口，里面存在一个get方法用来获取值

    练一练：使用线程池计算 从0~n的和，并将结果返回
 */
public class Test2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建指定线程数量的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);

        Future<Integer> future = threadPool.submit(new CalculateTask(100));
        Integer sum = future.get();
        System.out.println(sum);
    }
}

// 使用线程池计算 从0~n的和，并将结果返回
class CalculateTask implements Callable<Integer> {
    private int num;

    public CalculateTask(int num) {
        this.num = num;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;// 求和变量
        for (int i = 0; i <= num; i++) {
            sum += i;
        }
        return sum;
    }
}