Java的学习记录：charpter9.多线程

1.1基本概念

在介绍多线程之前我们得先了解一下几个概念：
1.程序：
是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
2.进程
是程序的一次执行过程，或是处于运行状态的一个应用程序。是一个动态的过程：有它自身的产生、存在和消亡的过程，即生命周期 。

3.线程(thread)
进程可进一步细化为线程，线程是CPU进行调度的最小单位，是一个程序内部的一条执行路径。
注意：
1.若一个进程同一时间并行执行多个线程，就是支持多线程的
2.线程作为CPU调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
4.单核CPU和多核CPU的理解
单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。
多核CPU:能更好的发挥多线程的效率。
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发：
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：多个人做同一件事。

5.线程的生命周期：

​ 1)创建线程对象： 新生 new born

​ 2)调用start方法后： 就绪：ready

​ 3)CPU调度后： 运行：running 阻塞 ：blocked (sleep/wait(0) ->notify)

​ 注意：阻塞状态正常结束后进入就绪状态

​ 4)run方法结束： 死亡：dead (自然死亡：循环结束，让循环条件不成立)

1.2多线程

1.为什么要使用多线程？
(1)程序需要同时执行两个或多个任务。
(2)程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作等。
(3) 需要一些后台运行的程序时。

2.多线程程序的优点：
(1) 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
(2)提高计算机系统CPU的利用率
(3)改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

3.创建线程的几种方法：
​ 1)匿名内部类创建线程

public class Test {
    public static void main(String[] args) {
    //匿名内部类
        Thread thread = new Thread(){
            @Override
            public void run() {
                for (int i = 1; i <=100 ; i++) {
                    System.out.println("mt :"+i);
                    //让线程休眠1000毫秒
//                    try {
//                        Thread.sleep(1000);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
                }
            }
        };
        thread.start();//线程启动的方法 start();
        thread.run();//调用run方法的话，结果是先执行完mt线程，再执行main主线程，是面向过程


        for (int i = 1; i <=100 ; i++) {
            System.out.println("main :"+i);
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
        }

    }
}

​ 2)自定义类型继承 Thread类
1.start():启动当前线程，执行当前线程的run()
2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread(): 静态方法，返回当前代码执行的线程
4.getName():获取当前线程的名字
5.setName():设置当前线程的名字
6.yield():释放当前CPU的执行权
7.stop():已过时。当执行此方法时，强制结束当前线程。
8.sleep(long millitime)：让当前线程“睡眠”指定时间的millitime毫秒)。在指定millitime毫秒时间内，当前线程是阻塞状态的。
9.isAlive()：返回boolean，判断线程是否还活着

语法示例：

class MyThread extends Thread{
//自定义属性
...
//自定义属性
...
@Override
public void run(){
...
}
}
Thread thread = new Thread();
thread.start();

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

 class MyRun implements Runable{
		//自定义属性
		...
		//自定义方法
		...
		
		@Override
		Public void run(){
		...
		}
}
Runable mr = new MyRun(...); 
Thread thread = new Thread(mr);
thread.start();

4.常见的几种线程池

	//缓存线程池 ：小型任务，瞬间存在的，线程开完就会被回收掉；线程可以一直开，即线程数可以是0，也可以是很大
    ExecutorService esc = Executors.newCachedThreadPool();
    //固定线程池：中大型任务，线程池数量固定
    ExecutorService esf = Executors.newFixedThreadPool(10);
    //单线程池：最多只开一条线程，如果该线程没了，会再开一条线程，且只开一条线程
    ExecutorService es1 = Executors.newSingleThreadExecutor();
    //定时任务线程池：兼具固定线程池和缓存线程池的优点；
   ScheduledExecutorService ses = Executors.newScheduledThreadPool(10);


	clss MyCall implement Callable<T>{
	//自定义属性
	...
	//自定义方法
	...
	
	@Override
	public T call(){
	...
	}
	}
	MyCall mc = new MyCall(...);
	Future<T> fu = esf.submit(mc);
	T t = fu.get();