2021-10-14

多线程技术概述

线程与进程

进程

• 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

• 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
• 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

线程调度

分时调度

• 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

• 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
• CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高

同步与异步

同步:排队执行 , 效率低但是安全.

异步:同时执行 , 效率高但是数据不安全.

并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）

线程实现的编写

1. 继承Thread

main方法为主线程，

在类中继承Thread类，并且重写run方法，启动线程即可。

每个线程都有自己的栈空间，共用一份堆内存。

//抢占式执行，主线程和MyThread线程随机抢占
MyThread m = new MyThread();
m.start();


public class MyThread extends Thread{
	//run方法就是线程要执行的任务方法
	@Override
	public void run(){
		//.......
	}

}

2. 实现Runnable

相对于继承Thread的优势：

1.通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程执行相同任务的情况。

2.可以避免单继承所带来的局限性。

3.任务与线程本身是分离的，提高了程序的健壮性。

4.后续学习的线程池技术，接收Runnable类型的任务，不接受Thread类型的线程。

//1.创建一个任务对象
MYRunnable r = new MyRunnable();
//2.创建一个线程，并为其分配一个任务
Thread t = new Thread(r);
//3.执行这个线程
t.start();




/**
* 用于线程实现的任务
*/
public class MyRunnable implements Runnable{
	//run方法就是线程要执行的任务方法
	@Override
	public void run(){
		//.......
	}

}

3.带返回值的线程Callable

Callable<Interger> c = new MyCallable();
FutureTask<Interger> task = new FutureTask<>(c);
new Thread(task).start;//如果不获取其返回值，该线程已经启动，主线程继续往下运行
Interger j = task.get();//使用该方法获取其返回值，主线程会等待该线程返回其返回值


static class MyCallable implements Callable<Interger>{
	@Override
	public Interger call() throw Exception{
		Thread.sleep(3000);
		return 100;
	}
	
}

Callable<Interger> c = new MyCallable();
FutureTask<Interger> task = new FutureTask<>(c);
new Thread(task).start;
task.isDone();//判断该线程是否结束
task.cancel(true);//返回true表示取消了该线程，返回false表示线程已经结束

Runnable 与 Callable的相同点

• 都是接口
• 都可以编写多线程程序
• 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

• Runnable没有返回值；Callable可以返回执行结果
• Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable****获取返回值

Callable接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

3. Thread类

3.1 获取和设置线程名称

sysout(Thread.currentThread().getName());//会得到 main
new Thread(new MyRunnable()).start();//会得到 Thread-0
new Thread(new MyRunnable()).start();//会得到 Thread-1 也可能是 Thread-0，不保证顺序
Thread t = new Thread(new MyRunnable());
t.setName("...");//设置线程名称
t.start();


public class MyRunnable implements Runnable{
	@Override
	public void run(){
		//.......获取现在运行的线程对象. 的名字
		sysout(Thread.currentThread().getName());
	}

}

3.2 线程休眠sleep

Thread.sleep(1000);//1000ms 即1秒

3.3 线程阻塞

理解为 所有消耗时间的操作 ，例如文件读取，线程会等待读取，即耗时操作

3.4 线程的中断

一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定。

使用stop()是十分不安全的，应设置一个标识使其自己结束。

Thread t1 = new Thread(new MyRunnable());
t1.start();
for(int i = 0; i <= 5; i++){
	sout(Thread.currentThread().getName()+""+i);
	try{
		Thread.sleep(1000);
	}catch(e){
		e.print;
	}
}
//给线程t1添加中断标记，此处为当上面的程序执行完后，对t1进行中断
//线程t1捕捉到这个中断时，进入catch语句
t1.interrupt();



public class MyRunnable implements Runnable{
	@Override
	public void run(){
		for(int i = 0; i <= 10; i++){
			sout(Thread.currentThread().getName()+""+i);
			try{
				Thread.sleep(1000);
			}catch(e){
				//当发现中断标记块时，进入catch块，进行下面程序，可以不死亡
				return;//return表示线程结束
			}
		}
		
	}

}

3.5 守护线程

线程分为守护线程和用户线程。

用户线程：当一个进程不包含任何存活的用户线程时，进行结束。

守护线程：守护用户线程,当最后一个用户线程结束时，所有守护线程自动死亡。

Thread t1 = new Thread(new MyRunnable());
t1.start();
for(int i = 0; i <= 5; i++){
	sout(Thread.currentThread().getName()+""+i);
	try{
		Thread.sleep(1000);
	}catch(e){
		e.print;
	}
}//当主线程死亡时，t1线程仍然会继续执行

//将其改为守护线程，主程序死亡时，它也随之死亡
Thread t1 = new Thread(new MyRunnable());
t1.setDaemon(true);
t1.start();





public class MyRunnable implements Runnable{
	@Override
	public void run(){
		for(int i = 0; i <= 10; i++){
			sout(Thread.currentThread().getName()+""+i);
			try{
				Thread.sleep(1000);
			}catch(e){
				e.print;
			}
		}
		
	}

}

3.6 线程安全问题

//线程不安全
Runnable run = new Ticket();
new Thread(run).start();
new Thread(run).start();
new Thread(run).start();
//票数一定，当多个线程线程
static class Ticket implements Runnable{
	private int count = 10;//票数
	@Override
	public void run(){
		//卖票
        while(count > 0){
        	sout("出票中");
        	try{
				Thread.sleep(1000);
			}catch(e){
				e.print;
			}
        	count--;
        	sout("出票成功，余票："+count)
        }
	}
}
//运行会出现余票负数。因为三个线程依次启动，
//某个线程在sleep时，即使没有sleep，在走中间代码时也会耗费一些时间，虽然很短。
//于是，在这一段时间内，count仍然是大于0的，其他线程依然可以进入，会进行后面的--操作。


//所以，只要在一个线程走中间代码时，不允许其他线程进入即可，即排队执行

3.6.1 线程安全1-同步代码块

//格式:  synchronized(锁对象){
//
//		}



Runnable run = new Ticket();
new Thread(run).start();
new Thread(run).start();
new Thread(run).start();
//票数一定，当多个线程线程
static class Ticket implements Runnable{
	private int count = 10;//票数
	private Object o = new Object();//同一个属性
	
	@Override
	public void run(){
        //.......		
        //卖票
        while(true){
        	synchronized(o){//使用的是同一个对象o，即同一把锁,三个线程看一把锁
                if(count > 0){
                	sout("出票中");
                	try{
                    	Thread.sleep(1000);
                	}catch(e){
                    	e.print;
                	}
                	count--;
               	 	sout("出票成功，余票："+count)
                }else{
                    break;
                }
        	}
     	}
	}
}

3.6.2 线程安全2-同步方法

//
static class Ticket implements Runnable{
	private int count = 10;//票数
	
	@Override
	public void run(){
        while(true){
        	boolean flag = sale();
        	if(!flag){
        		break;
        	}
     	}
	}
    //加上synchronized修饰
    public synchronized boolean sale(){
        //this  非静态方法时的锁
        //Ticket.class    静态方法时的锁
        if(count > 0){
            sout("出票中");
            try{
                Thread.sleep(1000);
            }catch(e){
                e.print;
            }
            count--;
            sout("出票成功，余票："+count)
            return true;
        }
        return false;
    }
}

3.6.3 线程安全3-显示锁Lock

//显示锁 Lock 子类 ReentrantLock
//自己窗机锁对象，自己锁，自己解锁

static class Ticket implements Runnable{
	private int count = 10;//票数
	//显示锁
	private Lock l = new ReentrantLock();
	
	@Override
	public void run(){
        while(true){
        	l.lock();//上锁
        	if(count > 0){
            	sout("出票中");
            	try{
                	Thread.sleep(1000);
            	}catch(e){
                	e.print;
            	}
            	count--;
            	sout("出票成功，余票："+count)
        	}else{
        		break;
        	}
            l.unlock();//解开锁
     	}
	}      
}

3.6.4 公平锁 与 非公平锁

//公平锁：先来先到，每个线程排队，一个一个进行。

//非公平锁：Java默认为非公平锁，大家一起抢，谁抢到就是谁的

实现：

//显示锁 l: fair参数为true，就表示 是公平锁

private Lock l = new ReentrantLock(true);

3.6.5 线程死锁

//线程相互等待，造成死锁。

3.7 多线程通信问题

生产者与消费者的问题

Food f = new Food();
new Cook(f).start();//厨师做菜线程
new Waiter(f).start();//服务员取菜线程


//
static class Cook extends Thread{
	private Food f;
	public Cook(Food f){
		this.f = f;
	}
	@Override
	public void run(){
		for(i=0;i<100;i++){
			if(i%2==0){
				f.setNameAndTaste("老干妈小米粥", "香辣味");
			}else{
				f.setNameAndTaste("煎饼果子", "甜辣味");
			}
		}
	}
}

//
static class Waiter extends Thread{
	private Food f;
	public Cook(Food f){
		this.f = f;
	}
	@Override
	public void run(){
		for(i=0;i<100;i++){
			try{
                	Thread.sleep(1000);
            	}catch(e){
                	e.print;
            	}
			f.get();
		}
	}
}

//
static class Food {
	private String name;
	private String taste;
	public void setNameAndTaste(String name, String taste){
		this.name = name;  	//协调工作时，厨师刚改名字，味道还没改，菜就被服务员端走了，味道没改。直接用线程安全，是不公平的，也容易出现错误。还是得采用一边做菜一边休息的方式
		Thread.sleep(100);//100ms
		this.taste = taste;
	}
	public void get(){
		sout("服务员端走的菜的名称是："+name+"味道："+taste);
	}
}

//

Food f = new Food();
new Cook(f).start();//厨师做菜线程
new Waiter(f).start();//服务员取菜线程


//
static class Cook extends Thread{
	private Food f;
	public Cook(Food f){
		this.f = f;
	}
	@Override
	public void run(){
		for(i=0;i<100;i++){
			if(i%2==0){
				f.setNameAndTaste("老干妈小米粥", "香辣味");
			}else{
				f.setNameAndTaste("煎饼果子", "甜辣味");
			}
		}
	}
}

//
static class Waiter extends Thread{
	private Food f;
	public Cook(Food f){
		this.f = f;
	}
	@Override
	public void run(){
		for(i=0;i<100;i++){
			try{
                	Thread.sleep(1000);
            	}catch(e){
                	e.print;
            	}
			f.get();
		}
	}
}

//
static class Food {
	private String name;
	private String taste;
	private boolean flag = true;//true表示可以生产，false可以端菜
	
	public void setNameAndTaste(String name, String taste){
		if(flag){
            this.name = name;  	
            Thread.sleep(100);//100ms
            this.taste = taste;
            flag = false;
            this.notifyAll();//唤醒所有线程
            this.wait();//等待
       	}
	}
	public void get(){
		if(!flag){
			sout("服务员端走的菜的名称是："+name+"味道："+taste);
			flag = true;
			this.notifyAll();//唤醒所有线程
            this.wait();//等待
		}
	}
}

3.8 线程的六种状态

4 线程池概述

线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

• 降低资源消耗。
• 提高响应速度。
• 提高线程的可管理性

Java中的四种线程池.

1.缓存线程池

/*** 缓存线程池. 
* (长度无限制) 
* 执行流程: 
* 1. 判断线程池是否存在空闲线程 
* 2. 存在则使用 
* 3. 不存在,则创建线程 并放入线程池, 然后使用 
*/ 
ExecutorService service = Executors.newCachedThreadPool(); //向线程池中 加入 新的任务 
service.execute(new Runnable() { 
    @Override public void run() { 
        System.out.println("线程的名称:" + 
                          Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override public void run() { 
        System.out.println("线程的名称:" + 
                          Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override public void run() { 
        System.out.println("线程的名称:"+ 
                          Thread.currentThread().getName()); 
    } 
});

2. 定长线程池

/*** 定长线程池. 
* (长度是指定的数值) 
* 执行流程:
* 1. 判断线程池是否存在空闲线程 
* 2. 存在则使用 
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 
*/ 
ExecutorService service = Executors.newFixedThreadPool(2); service.execute(new Runnable() { 
	@Override public void run() { 
		System.out.println("线程的名称:"+ 			  
                          Thread.currentThread().getName()); 
		} 
}); 
service.execute(new Runnable() { 
	@Override public void run() { 
		System.out.println("线程的名称:"+ 
                          Thread.currentThread().getName()); 
    } 
});

3. 单线程线程池

效果与定长线程池 创建时传入数值1 效果一致. 
/*** 单线程线程池. 
* 执行流程: 
* 1. 判断线程池 的那个线程 是否空闲 
* 2. 空闲则使用 
* 4. 不空闲,则等待 池中的单个线程空闲后 使用 
*/ 
ExecutorService service=Executors.newSingleThreadExecutor(); service.execute(new Runnable() { 
    @Override public void run() { 
        System.out.println("线程的名称:"+ 
                          Thread.currentThread().getName()); 	} 
}); 
service.execute(new Runnable() { 
    @Override public void run() { 
        System.out.println("线程的名称:"+
                          Thread.currentThread().getName()); 	} 
});

4.周期性任务定长线程池

 /*** 周期任务 定长线程池. 
 * 执行流程: 
 * 1. 判断线程池是否存在空闲线程 
 * 2. 存在则使用 
 * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
 * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 
 ** 周期性任务执行时: 
 * 定时执行, 当某个时机触发时, 自动执行某任务 .
*/ 
ScheduledExecutorService service = Executors.newScheduledThreadPool(2); 

/*** 定时执行 
* 参数1. runnable类型的任务 
* 参数2. 时长数字 (延迟执行的时长) 
* 参数3. 时长数字的单位 ，TimeUntil的常量指定
*/ 
/*

//任务于五秒钟后执行
service.schedule(new Runnable() {
	@Override public void run() { 
		System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
	} 
},5,TimeUnit.SECONDS); 
*/


/*** 周期执行 
* 参数1. runnable类型的任务 
* 参数2. 时长数字(延迟执行的时长) 
* 参数3. 周期时长(每次执行的间隔时间) 
* 参数4. 时长数字的单位 
*/ 

//5秒钟后执行，没隔2秒执行一次
service.scheduleAtFixedRate(new Runnable() { 
    @Override public void run() { 
        System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
    } 
},5,2,TimeUnit.SECONDS); }

5 Lambda表达式

/**
*Lambda表达式
*函数式编程思想
*注重于方法，而不是对象
*将匿名对象类的方法提取出来按格式书写即可
*/
Thread t = new Thread(()->{
    System.out.println("锄禾日当午");
});
t.start();


print((int x, int y) ->{
	return x+y;
},x: 100, y: 200);