多线程详解-01

• 线程简介
• 线程实现（重点）
• 线程状态
• 线程同步（重点）
• 线程通信问题
• 高级主题

01 线程简介

多任务

• 现实中太多同时做多件事的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事。

多线程

• 有一条公路，慢慢因为车太多了，道路堵塞，效率极低。
• 为了提高使用的效率，能够充分利用道路，于是加了多个车道。
• 从此，车道就不再堵塞了。

普通方法调用和多线程

程序、进程、线程

• 在操作系统中运行的程序就是进程，比如你的QQ，播放器，游戏，IDE等。。。
• 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等。

Process与Thread

• 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态概念。
• 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

注意：很多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所有就有同时执行的错局。

本章核心概念

• 线程就是独立的执行路径；
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
• main（）称之为主线程，为系统的入口，用于执行整个程序；
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
• 线程会带来额外的开销，如cpu调度时间，并发控制开销。
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

02 线程创建

三种创建方式

• Thread class-继承Thread类（重点）
• Runnable-实现Runnable接口（重点）
• Callable-实现Callable接口（了解）

Thread

• 自定义线程类继承Thread类
• 重写run（）方法，编写线程执行体
• 创建线程对象，调用start（）方法启动线程

public class StartThread1 extends Thread{

	//线程入口点
	@Override
	public void run(){
		//线程体
		for(int i = 0;i < 20;i++){
			System.out.println("我在听课====");
		}
	}
}

public static void main(String[] args){

	//创建线程对象
	StartThread1 t = new StartThread1();
	t.start();
}

线程不一定立即执行，CPU安排调度

案例：下载图片

第一步

//文件下载工具类
class WebDownloader{
	//远程路径，存储名字
	public void downloader(String url,String name){
		try{
			//Commons IO是针对开发IO流功能的工具类库。
			//FileUtils文件工具，复制url到文件
			FileUtils.copyURLToFile(new URL(url),new File(name);
		}catch(IOException e){
			e.printStackTrace();
			System.out.println("文件下载失败")；
		}
	}
}

第二步

@Override
public void run(){
	WebDownloader webDownloader = new WebDownloader();
	webDownloader.downloader(url,name);
	System.out.println(name);
}

第三步

public static void main(String[] args){
	StartThread2 t1 = new StartThread2("url1","n1");
	StartThread2 t2 = new StartThread2("url2","n2");
	StartThread2 t3 = new StartThread2("url3","n3");
	
	//启动三个线程
	t1.start();
	t2.start();
	t3.start();
}

实现Runnable

• 定义MyRunnable类实现Runnable接口
• 实现run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

public class StartThread3 implements Runnable{
	@Override
	public void run(){
		//线程体
		for(int i = 0;i < 20;i++){
			System.out.println("我在听课====");
		}
	}
}

//创建实现类对象
StartThread3 st = new StartThread3();
//创建代理类对象
Thread thread = new Thread(st);
//启动
thread.start();

推荐使用Runnable对象，因为Java单继承的局限性

小结

• 继承Thread类
  子类继承Thead类具有多线程能力
  启动线程：子类对象.start()
  不建议使用：避免OOP单继承局限性
• 实现Runnable接口
  实现接口Runable具有多线程能力
  启动线程：传入目标对象+Thread对象.start()
  推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

//一份资源
StartThread4 station = new StartThread4();
//多个代理
new Thread(station,"小明").start();
new Thread(station,"老师").start();
new Thread(station,"小红").start();

实现Callable接口（了解即可）

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5. 提交执行：Future< Boolean > result1 = ser.submit(1);
6. 获取结果：boolean r1 = result1.get();
7. 关闭服务：ser.shutdownNow();

public class TestThread2 implements Callable {

    private String url;
    private String name;
    public TestThread2(String url,String name){
        this.url = url;
        this.name = name;
    }
    @Override
    public Object call() throws Exception {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println(name);
        return true;
    }
    public static void main(String[] args) throws ExecutionException,InterruptedException {
        TestThread2 t1 = new TestThread2("url1","n1");
        TestThread2 t2 = new TestThread2("url2","n2");
        TestThread2 t3 = new TestThread2("url3","n3");
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future< Boolean > result1 = ser.submit(t1);
        Future< Boolean > result2 = ser.submit(t2);
        Future< Boolean > result3 = ser.submit(t3);
        //获取结果
        boolean r1 = result1.get();
        boolean r2 = result1.get();
        boolean r3 = result1.get();
        //关闭服务
        ser.shutdownNow();
}
    //文件下载工具类
    class WebDownloader{
        //远程路径，存储名字
        public void downloader(String url,String name){
            try{
                //Commons IO是针对开发IO流功能的工具类库。
                //FileUtils文件工具，复制url到文件
                FileUtils.copyURLToFile(new URL(url),new File(name);
            }catch(IOException e){
                e.printStackTrace();
                System.out.println("文件下载失败")；
            }
        }
    }

静态代理

• 你：真实角色
• 婚庆公司：代理你，帮你处理结婚的事
• 结婚：实现结婚接口即可

public class StacticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
//
//真实对象和代理对象都要实现同一个接口
interface Marry{
    void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("小明要结婚了，超开心");
    }
}
//代理角色，帮助你结婚
class WeddingCompany implements Marry{
    //代理谁-->真实对象
    private Marry target;

    public WeddingCompany(Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//真实对象
        after();
    }
    private void before(){
        System.out.println("结婚之前，布置现场");
    }
    private void after(){
        System.out.println("结婚之后，收尾款");
    }
}

好处：
代理对象可用做很多真实对象做不了的事情
真实对象专注做自己的事情

Lambda表达式

• λ希腊字母表中排序第十一位的字母，英文名称为Lambda
• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念

(params)->expression[表达式]
(params)->statement[语句]
(params)->{statements}

//例如
a->System.out.println("i like lambda-->"+a);

new Thread (()->System.out.println("多线程学习。。。")).start();

• 为什么要使用lambda表达式
  避免匿名内部类定义过多
  可以让你的代码看起来很简洁
  去掉一堆没用意义的代码，只留下核心的逻辑。
• 理解Functionl Interface(函数式接口）是学习Java8 lambda表达式的关键所在。
• 函数式接口的定义：
  任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

public interface Runnable{
	public abstract void run();
}

对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

public class TestLambda{
	//静态内部类
	static class Like2 implements ILike{
		@Override
		public void lambda(){
			System.out.println("i like lambda2");
		}
	}
	public static void main(String[] args){
		ILike like = new Like();
		like.lambda();
		
		like = new Like2();
		like.lambda();
		
		//局部内部类
		class Like3 implements ILike{
			@Override
			public void lambda(){
				System.out.println("i like lambda3");					
			}
		}
		like = new Like3();
		like.lambda();
		
		//匿名内部类，没有类的名称，必须借助接口或者父类
		like = new ILike(){
			@Override
			public void lambda(){
				System.out.println("i like lambda4");					
			}
		}

		//用lambda简化
		like = ()->(
			System.out.println("i like lambda5");
		);
		like.lambda();
	}
}
//定义一个函数式接口
interface ILike{
	void lambda();
}

//实现类
class Like implements ILike{
	@Override
	public void lambda(){
		System.out.println("i like lambda");					
	}
}

总结：
lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
前提是接口为函数式接口
单个参数可以去掉参数类型和括号
多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号