JAVA学习十：多线程

多线程
1.线程与进程
进程：指一个内存中运行的应用程序，每一个进程的内存空间都是独立的，且是互不共享的。
线程：是进程中的一个个的执行路径，多个线程间共享一块内存空间，线程之间可以自由切换，并发执行，一个进程至少有一个线程。
线程实际上是进程基础上的进一步划分，一个进程启动后，里面的若干执行路径可以划分称为若干线程。

2.同步与异步
同步：排队执行。效率低但是安全。
异步：同时执行。效率高但是数据不安全。

3.并发与并行

并发：指两个或多个事件在同一时间段内发生。（比如一天内发生的事情）
并行：指两个或多个事件在同一时刻（同时发生）。

4.Thread
如何 继承线程类Thread

public class MyThread extends Thread{
//重写run方法
public void run(){
//这里的代码  就是一条新的执行路径
//这个执行路径的触发方式。不是调用run方法，而是通过Thread对象的start（）来启动任务
for(int i=0;i<10;i++){
System.out.print(“锄禾日当午”+i);
}
}
}

main（）{
MyThread m = new MyThread();
m.start();//开启分支线程
System.out.print(这是主线程);
}

每个线程都有自己的栈空间。共用一份堆内存。
由一个线程调用的方法，这个方法也执行在这个线程中。

5.实现Runnable
实现Runnable与继承Thread相比有如下优势：
1.通过创建任务，然后给线程分配的方式来实现多线程。更适合多个线程同时执行相同任务的情况。
2.可以避免单继承所带来的局限性。（继承了一个类就无法继承其他类）
实现Runnable可以实现多个接口，还可以继承其他类。
3.任务与线程本身是分离的。提高了程序的健壮性。
4.后续学习的线程池技术，只接受Runnable类型的任务，而不接受Thread类。

/**
*用于给线程进行执行的任务
*/
public class MyRunnable implements Runnable{
//线程的任务,重写run方法
public void run(){
for(int i=0;i<10;i++){}
}
}

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

Thread类的优势：通过匿名内部类使用线程，代码更简单

main(){
//通过匿名内部类创建Thread对象来使用这条线程
new Thread(){
for();//内部的执行语句
}
}.start();//直接使用匿名对象调用start方法。

5.Thread类
6.Thread类

构造方法：
//单纯new一个线程，没有任务
1.new Thread();
//传入一个任务对象Runnable
2.new Thread(Runnable r);
//传入任务对象并给它一个名称
3.new Thread(Runnable r,String name);

常用方法：

getId();//返回线程的ID
getName();//返回线程的名称
getState();//返回线程的状态
getPriority();//返回线程的优先级
setPriority(int)//设置线程优先级：
优先级传入的参数为常量，三个静态修饰的int值
static int Max_PRIORITY/MIN_PRIORITY/NORM_PRIORITY
最大优先级/最小优先级/默认优先级

stop();停止线程---已过时，非常不安全。
想要停止线程时，应该通知线程结束，可以在某个地方定义一个变量，
当变量值变化时，给任务return就能通知线程关闭。

sleep(long millis);暂时休眠这条线程，传入毫秒

setDaemon(boolean on);将此线程标记为daemon线程或用户线程。
daemon即守护线程，跟用户线程最大的区别是死亡的时机，
当所有用户线程死亡时自动死亡。

7.线程名称

//String name = Thread.currentThred().getName();
静态方法：获取当前线程	获取名称
在main方法中直接使用此方法，返回“main”。

Thread t = new Thread(new MyRunnable());
t.setName();//将调用的线程设置名称
t.start();

线程的休眠

for(int i=0;i<10;i++){
System.out.print(i);
//如果想一秒钟输出一次i，可以使用休眠
Thread.sleep(1000);//每隔1000毫秒休眠一次
}

线程阻塞
可以理解为所有比较消耗时间的操作，比如文件读取，
它会导致线程等待文件读取完毕，就会堵在那里
还有等待用户输入。也可以称之为耗时操作。

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

9.守护线程
new Thread(new MyRunnable()).setDaemon(true);

10.线程安全问题
//线程不安全

Runnable run = new Ticket();
new Thread(run).start();
new Thread(run).start();
new Thread(run).start();
//三条线程公用一个任务，多条线程去争抢一个数据，可能导致数据在判断时和使用时发生数据错乱，容易引发线程不安全。

线程安全解决方案1-同步代码块
为使多条线程不会争抢一个数据，可以使线程排队执行。即加锁。

synchronized：是隐式锁
格式：synchronized(锁对象){这个代码块就是需要排队执行的代码}
java中任何对象都可以作为锁标记。

当线程执行代码块的代码时，会观察锁对象是否打上了锁的标记。
当线程观察到上锁时会一直等待解锁，代码块结束时会解锁，
等待的线程就会去争抢这个锁，然后在上锁。

解决方案2-同步方法
也是加锁，写法跟代码块不同。

synchronized
修饰在任务线程内的方法：
public synchronized void sale(){
这样这个方法就是排队执行的。
}
//线程的同步方法的锁，就是this-线程任务创建的对象。
//如果是静态的同步方法，就是线程.class。

如果同步代码块和同步方法用同一个锁，那么某个线程执行其中一个的时候，另一个代码也是执行不了。

解决方案3-显示锁
显示锁Lock子类ReentrantLock

Lock l = new ReentrantLock();
public void run(){
l.lock();
{}
l.unlock();
}

公平锁和非公平锁
java默认的锁为非公平锁，即一旦解锁，所有线程同时抢锁。
公平锁则是，锁定期间线程开始排队，解锁后按照顺序进行使用。

Lock l = new ReentrantLock(true/false);
传入参数为true即为公平锁，默认false

11.线程死锁
两个线程都锁住了两个任务，它们都想进对方的线程时，对方的锁都是锁住的，因此两个线程都卡死在这里，这被称为线程死锁。

如何解决：
在任何有可能有锁产生的方法里，不要再调用其他可能产生锁的方法。

12.多线程通信
多线程通信问题，生产者与消费者问题

//厨师类:生产者
static class Cook extends Thread{
private Food f;
public Cook(Food f){
this.f = f;
}
public void run(){f.set();循环100次，分别传入两种饭的名称和味道}
}
//服务员：消费者
static class Waiter extends Thread{
private Food f;
public Waiter(Food f){
this.food = f;
}
public void run(){f.get();}
}
//食物
static class Food{
private String name;
private String taste;
public void setNameAndTaste(String name,String taste){
this.name = name;//对传入的对象进行赋值
Thread.sleep(100); 
this.taste = taste;
}
public void get(){
System.out.print(name+taste);
}
}
main(){
Food f = new Food();
new Cook(f).start();
new Waiter(f).start();
}
//此时由于两个线程交替任务，传入的f食物就可能发生数据错乱。

如果光加线程安全无法解决问题，A线程执行完可能马上就继续回手执行。

//解决方法：
定义一个flag标记，给生产一个if判断标记为true才能进入，当生产(set)结束后标记为false，此时就无法进入生产方法。
消费则为false的时候才可以进入任务。
两者运行结束后都使用this.notifyAll()唤醒自己以外的全部线程，再使用
this.wait();使自己进入休眠状态。

13.线程的6种状态
new：线程刚被创建，但是还未启动
Runnable：正在执行
Blocked：被阻塞，等待（当一个线程跟其他线程排队时）
Waiting：无限等待直到某个线程唤醒它
TimedWaiting：指定时间到时唤醒，也可以直接被唤醒
Trminated：终止

14.带返回值的线程Callable
接口，需要实现。为主线程指派给它的任务，返回值会被主线程拿到。
使用方法：
1.编写类实现Callable接口，实现call方法：

class XXX implements Callable<T>{
public <T> call() throws Exception{
return T;
}
}

2.创建FutureTask对象，并传入第一步编写的Callable对象：

FutureTask<Integer> future = new FutureTask<>(callable);

3.通过Thread启动线程

new Thread(future).start();

FutureTask方法：
get();获取线程执行的结果，如果调用此方法，主线程会等待支线程返回结果。
cancle();取消这个线程继续执行。

15.线程池概述
//流程：创建线程：正常情况下花费的时间都是创建和关闭线程，这样会浪费大量时间
//创建任务
//执行任务
//关闭线程

//频繁创建线程会大大降低系统的效率，线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量时间和资源。

非定长线程池：线程池中会存在数个线程，当有任务来时会使用内部的线程执行任务，当所有线程都处在运行状态时，新来的任务会自动创建一个新线程，执行完毕后也会被缓存在线程池中，此缓存也会自动清理。

定长线程池：（长度指定数值）
1.判断线程池中是否有空闲线程
2.存在则使用
3.不存在空闲线程且线程池未满，创建线程放入线程池并使用
4.不存在空闲线程且已满，则等待线程池空余出来

单线程线程池：
只有一个线程

周期性任务定长线程池：
当时机触发时，自动执行某任务

缓存线程池：
新建线程池对象
ExecutorService service = Executors.newCachedThreadPool();
//指挥线程池中加入并执行新任务，不需要start
service.execute(new Runnable(){
System.out.print();
})

定长线程池：
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable());

单线程线程池:
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable());

周期性任务定长线程池:
ScheduledExecutorService service = Executor.newScheduledThreadPool(2);
//1.定时执行一次
参数1.定时执行的任务
参数2.时长数字
参数3.时长数字的时间单位TimeUnit的常量指定（）
service.schedule(new Runnable(),5,TimeUnit.SECONS);//这个任务在5秒钟后执行

//如何周期执行
参数1.任务
参数2.延时时长数字：第一次执行在什么时候以后
参数3.周期时长数字：第一次开始后往后每隔多久执行一次
参数4.时长单位
service.scheduleAtFixedRate(new Runnable(),5,1,TimeUnit.SECONDS);
第一次5秒后，每隔一秒执行一次。
16.Lambda表达式
函数式变成思想
面向对象： 创建对象调用方法 解决问题
Lambda表达式语法：

Thread t = new Thread((参数列表) -> {System.out.print()});

用于替换匿名内部类

Thread t = new Thread(new Runnable(){
public void run(){System.out.print}
});

函数式表达式关注的是方法。只传递方法，不传递对象。