多线程
什么是进程？
windows电脑中，打开任务管理器，可以看到电脑中执行的每一个程序，每一个程序就是一个进程。Windows系统是一个多任务系统。电脑可以同时执行多个程序。
CPU时间片概念：
什么是线程？
电脑管家是一个程序 ==> 进程
电脑可以同时开启 病毒查杀，垃圾清理，一键加速…每一个功能就可以看做是线程！
一个应用程序 ==> 进程
应用程序的某一个功能 ==> 线程
应用程序中可以同时执行多个功能 ==> 多线程
线程使用的是系统资源，该系统资源是操作系统分配给当前进程使用的。
多个线程的情况下，同时【抢占执行】会导致资源紧缺。
这里抢占过程就类似于进程抢占过程。
一个Java程序，最少有几个线程？
2个线程：
- main线程。
- JVM的GC机制，守护线程。
并发和并行
并发:两个或者两个以上的事务在同一个时间段发生
并行:两个或者两个以上的事务在同一个时刻发生
宏观并行，微观串行高并发事件：
双十一、JD 618、12306、中午下课的餐厅
同时在一个时间段以内，很多事情都发生了，这就是高并发。
多线程
多线程的优缺点
优点
- 提升资源利用率
- 提高用户体验
缺点:
3. 降低了其他线程的执行概率
4. 用户会感受到软件的卡顿问题
5. 增加的系统，资源压力
6. 多线程情况下的共享资源问题，线程冲突，线程安全问题
创建自定义线程类的两种方式
1.class Thread类，Java中的一个线程类
Thread类是Runnable接口的实现类，同时提供了很多线程的操作使用的方法。
2.interface Runnable接口
这里规定了what will be run? 里面只有一个方法 run方法。
方式一:
定义线程类，继承Thread类，重写run方法
创建自定义线程对象，直接调用start方法，开启线程方式二：
自定义线程类，遵从Runnable接口
使用自定义遵从接口Runnable实现类对象，作为Thread构造方法参数
借助于Thread类对象和start方法，开启线程【推荐】
以上两种方式，推荐使用方法二，遵从Runnable接口来完成自定义线程，不影响正常的继承逻辑，并且可以使用匿名内部类来完成线程代码块的书写。
*
* 自定义线程类MyThread1继承Thread类
*/
class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("继承Thread类自定义线程类");
}
}
}
/*
* 自定义线程类MyThread2遵从Runnable接口
*/
class MyThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("遵从Runnable接口实现自定义线程类");
}
}
}
public class Demo1 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("匿名内部类方式创建对象，作为线程执行代码");
}
}
}).start();
// 创建一个继承Thread类自定义线程类对象
MyThread1 myThread1 = new MyThread1();
// 这里不是启动线程，而且将run方法做出一个普通方法执行。
// myThread1.run();
myThread1.start();
// 创建一个Thread类对象，使用遵从Runnable接口的实现类作为构造方法参数
Thread thread = new Thread(new MyThread2());
// 借助于Thread类内的start方法开启线程
thread.start();
for (int i = 0; i < 100; i++) {
System.out.println("main线程");
}
}
}自定义线程执行流程简述
如图：
Thread类需要了解的方法
构造方法 Constructor：
Thread();
分配一个新的线程对象，无目标，无指定名字
Thread(Runnable target);
创建一个新的线程对象，并且在创建线程对象的过程中，使用Runnable接口的实现类
对象作为执行的线程代码块目标
Thread(String name);
创建一个新的线程，无指定目标，但是指定当前线程的名字是什么
Thread(Runnable target, String name);
创建一个线程的线程对象，使用Runnable接口实现类对象，作为执行目标，并且指定
name作为线程名成员方法:
void setName(String name);
String getName();
以上两个是name属性setter和getter方法
void setPriority(int Priority);
设置线程的优先级，非一定执行要求，只是增加执行的概率
优先级数值范围 [1 - 10] 10最高 1最低 5默认
int getPriority();
获取线程优先级
void start();
启动线程对象
public static void sleep(int ms);
当前方法是静态方法，通过Thread类调用，要求是当前所在线程代码块对应的线程，
进行休眠操作，休眠指定的毫秒数
public static Thread currentThread();
当前方法是静态方法，通过Thread类调用，获取当前所处代码块对应的线程对象。线程安全问题和解决方案
线程安全问题–共享资源能使用问题
<湄公河行动>> 100张票
淘票票CGV 美团 猫眼
三个销售渠道，100张票是一个共享资源！！！
三个销售渠道，可以认为是三个销售线程！！！问题一：
100张票共享资源问题，选什么来保存？局部变量：
在方法内，如果run方法执行，存在，run方法当前执行完毕，销毁。
每一个线程对象中都有run方法，无法满足共享问题成员变量：
每一个线程对象中，都有一个对应的成员变量，非共享资源。静态成员变量：
属于类变量，所有的当前类对象，使用的静态成员变量都是一个，而且一处修改，
处处受影响。【共享资源】问题二:
资源冲突问题...
同步代码块
synchronized (/* 锁对象 */) {
}
/*
特征:
1. synchronized 小括号里面的对象是锁对象，并且要求如果是多线程的情况下，锁对象必须是同一个对象。
2. synchronized 大括号中的代码块就是需要进行同步的代码，或者说是加锁的代码，大括号里面的内容，有且只允许一个线程进入。
3. 同步代码块越短越好，在保证安全的情况下，提高性能
问题:
1. 目前锁对象感觉很随意，存在一定的隐患
2. 代码层级关系很复杂，看着有点麻烦
*/同步方法
synchronized 作为关键字来修饰方法，修饰的方法就是对应的同步方法，有且只允许一个线程进入，到底是谁来完成的加锁操作?
- 静态成员方法
锁对象，是当前类对应的字节码文件.class 类名.class - 非静态成员方法
锁对象就是当前类对象 this 选择同步方法
是否使用static修饰问题
- 如果非static修饰，要保证执行的线程对象有且只有一个，因为锁对象就是当前线程对象
- 如果是static修饰，锁对象具有唯一性，多个线程使用的锁是同一个锁。
Lock锁
Java提供了一个对于线程安全问题，加锁操作相对于同步代码块和同步方法更加广泛的一种操作方式。
一、对象化操作。
创建Lock构造方法
Lock lock = new ReentrantLock();二、方法化操作。
开锁: unlock();
加锁: lock();三种加锁方式的总结
- 一锁一线程，一锁多线程问题。
使用对应的锁操作对应的线程，考虑静态和非静态问题。
同步方法和Lock锁使用。
静态是一锁多目标，非静态是一锁一目标 - 涉及到同步问题时，要考虑好锁对象的选择问题。同步代码块，同步方法，Lock对象。
守护线程
守护线程，也称之为后台线程，如果当前主线程废了，守护线程也就完犊子了。
守护线程一般用于:
- 自动下载
- 操作日志
- 操作监控
方法是通过线程对象：setDeamon(boolean flag);
true为守护线程
false缺省属性，正常线程线程状态
六种线程状态
线程中如果按照java.lang.Thread.State枚举方式来考虑，一共提供了6中状态。
NEW(新建) 线程刚刚被创建，没有启动，没有调用start方法
RUNNABLE(可运行) 线程已经可以在JVM中运行，但是，是否运行不确定，看当前
线程是否拥有CPU执行权
BLOCKED(锁阻塞) 当前线程进入一个同步代码需要获取对应的锁对象，但是发现当
前锁对象被其他线程持有，当前线程会进入一个BLOCKED。如果占用锁对象的线程
打开锁对象，当前线程持有对应锁对象，进入Runnable状态
WAITING(无限等待) 通过一个wait方法线程进入一个无限等待状态，这里需要另外一
个线程进行唤醒操作。进入无限等待状态的线程是无法自己回到Runnable状态，需要
其他线程通过notify或者notifyAll方法进行唤醒操作
TIMED_WAITING(计时等待) 当前线程的确是等待状态，但是会在一定时间之后自动
回到Runnable状态，例如 Thread.sleep() 或者是Object类内的wait(int ms);
TERMINATED(被终止)
因为Run方法运行结束正常退出线程，或者说在运行的过程中因为出现异常导致当前
线程GG思密达TIMED_WAITING(计时等待)
Thread.sleep(int ms);
在对应线程代码块中，当前线程休眠指定的时间。Object类内 wait(int ms);
让当前线程进入一个计时等待状态- 规定的时间及时完毕，线程回到可运行状态
- 在等待时间内，通过其他线程被notify或者notifyAll唤醒
Sleep方法：
- 调用之后休眠指定时间
- sleep方法必须执行在run方法内，才可以休眠线程
- sleep不会打卡当前线程占用的锁对象。
BLOCKED(锁阻塞)
线程中有锁存在，线程需要进入带有锁操作的同步代码，如果锁对象被别人持有，只能在锁外等待。
锁阻塞状态的线程是否能够抢到锁对象有很多因素
- 优先级问题，非决定因素。
- CPU执行概率问题。
后期高并发一定会存在多线程操作锁对象问题，秒杀，抢购…
队列方式来处理
线程状态 WAITING(无限等待)
当某一个线程被执行wait()方法，需要等待另外的一个线程进行唤醒操作。
以下三个方法都是Object类内的方法:
public void wait();
在哪一个线程中执行，就会让当前线程进入一个无限等待状态。- 所在线程进入无限等待状态
- 开启【锁对象】
public void notify();
唤醒和当前锁对象有关的无限等待线程中的一个，随机选择。- 唤醒一个无限等待状态线程
- 开启【锁对象】
public void notifyAll();
唤醒所有和当前锁对象有关的无限等待线程- 唤醒所有线程
- 开启【锁对象】
- 线程进入锁对象抢占过程，就有可能进入一个锁阻塞状态。
线程执行的所有状态分析图
线程通信
生活化例子
预约 --> 抢购
消费者 <–> 商品 <–> 生产者
消费者：
- 购买商品
- 等待，不过在等待之前，需要告知生产者快点生产
生产者：
- 生产商品
- 休息，在休息之前，要告知消费者你快来买啊
商品: 就是两个独立线程之间的共享资源。
共享资源处理问题
现在存在两个完全无关的线程，生产者和消费者，但是商品会作为他们两者之间的共享资源。
生产者和消费者中都有一个成员变量：商品类型
【解决方案】
创建生产者或者消费者线程对象时，使用同一个商品类对象，作为构造方法参数进行初始化操作。
设计程序
线程池
线程池
不管是继承Thread还是遵从Runnable接口，都需要重写Run方法，而且每一个线程对
象有且只能执行一次，之后就会被销毁。
利用Runnable接口来提供执行目标，而且借助于Thread执行线程。一个餐厅、服务人员
餐厅会按照餐桌比例安排服务员人数。每一个服务员我们都可以看做是一个线程对象，需要告知服务器做什么事情就可以了，相对于告知线程对象执行目标是什么，当你来餐厅之前，服务员在这里，你走之后，服务员依然在这里。
线程池 ==> 可以容纳多个线程的容器
程序可以从线程池获取线程来完成目标代码
同时也可以将线程归还给线程池。
省去了创建线程和销毁线程这样非常繁琐的操作。
线程池使用
public static ExecutorService
newFixedThreadPool(int nThreads);
得到一个线程对象，初始化参数是要求的当前线程池中的线程数public Future submit(Runnable target);
从线程池中获取一个线程对象，并且执行给定的Runnable接口实现类对象作
为执行目标import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyThread1 implements Runnable {
@Override
public void run() {
System.out.println("Runnable接口实现类，线程目标代码");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 明天吃土豆牛腩");
}
}
public class Demo1 {
public static void main(String[] args) {
// 1. 创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(5);
// 2. 创建一个MyThread1 Runnable接口实现类对象、
MyThread1 target = new MyThread1();
// 3. 使用线程池对象中的一个线程，指定目标代码
// 初始化线程数为5，这里使用的是线程池中已经存在的5个线程来执行代码
service.submit(target);
service.submit(target);
service.submit(target);
service.submit(target);
service.submit(target);
// 因为原本的5个线程都在被使用中，这里需要等待5个线程执行完毕，出现空闲线程
// 来执行对应的目标代码
service.submit(target);
service.submit(target);
// 4. 关闭线程池
// 一般不用关闭线程池，会随着程序的退出而关闭
// service.shutdown();
}
}从匿名内部类引入Lambda表达式
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo2 {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(5);
service.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
// lambda表达式
service.submit(() -> System.out.println(Thread.currentThread().getName()));
service.submit(() -> System.out.println(Thread.currentThread().getName()));
service.submit(() -> System.out.println(Thread.currentThread().getName()));
service.submit(() -> System.out.println(Thread.currentThread().getName()));
}
}Lambda表达式
思想 “说重点”
//Lambda
service.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
/*
匿名内部类方式来作为线程池执行目标代码
1. 这个方法需要的参数是Runnable接口的实现类对象
2. Runnable接口目标是为了提供一个run 方法， What will be run
3. What will be run??? where??? run方法内容
这里需要Runnable提供Run方法，提供Run方法方法体
"说重点"
需要Run方法方法体
*/Lambda表达式格式
service.submit(() -> System.out.println(Thread.currentThread().getName()));
/*
() ->
System.out.println(Thread.currentThread().getName())
Lambda表达式
() 参数列表
-> 做什么事情，就是对应方法体
箭头之后的代码就是正常语句
(参数列表) -> {代码语句}
*/Lambda表达式使用，无参数无返回值
/*
* 无参数无返回值
*/
interface Cook {
void cooking();
}
public class Demo1 {
public static void main(String[] args) {
invokeCook(new Cook() {
@Override
public void cooking() {
System.out.println("麻辣香锅，孜然肉片，土豆牛肉，蒜薹肉丝");
}
});
invokeCook(() -> {
System.out.println("蒜蓉油麦菜，番茄鸡蛋");
});
invokeCook(() -> System.out.println("明天早上自己炸油条"));
}
/**
* 执行Cook实现类对象方法
*
* @param cook Cook接口的实现类对象
*/
public static void invokeCook(Cook cook) {
cook.cooking();
}
}Lambda表达式使用，有参数有返回值
import java.util.Arrays;
import java.util.Comparator;
public class Demo2 {
public static void main(String[] args) {
Person[] persons = {
new Person("XX", 16),
new Person("XX", 50),
new Person("XX", 40),
new Person("XX", 35),
new Person("XXX", 14),
new Person("XXX", 18),
};
// public static <T> void sort(T[] a, Comparator<? super T> c)
Arrays.sort(persons, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
/*
* 1. 有参数
* 2. 有返回值
*
* (Person o1, Person o2) -> {
* return o1.getAge() - o2.getAge();
* }
* 标准Lambda
*/
Arrays.sort(persons, (Person o1, Person o2) -> {
return o2.getAge() - o1.getAge();
});
/*
* 1. 这里可以省略数据类型
* 2. 可以直接利用返回值，{}和return都省了掉
*/
Arrays.sort(persons, (o1, o2) -> o2.getAge() - o1.getAge());
for (Person person : persons) {
System.out.println(person);
}
}
}
/*-------------------------------------------------------------------*/
interface A {
float add(int num1, float num2);
}
public class Demo3 {
public static void main(String[] args) {
System.out.println(new A() {
@Override
public float add(int num1, float num2) {
return num1 + num2;
}
}.add(5, 13.5F));
/*
* 1. 数据类型真的可以省略，虽然是不同数据类型，Java语言真香
* 2. 实现的代码非一行，可以在大括号内完成你的目标
*/
test(5, 13.5F, (num1, num2) -> {
float sum = num1 + num2;
return sum;
});
}
public static void test(int num1, float num2, A a) {
System.out.println(a.add(num1, num2));
}
}Lambda表达式使用前提
- 有且只有一个缺省属性为public abstract方法的接口，
例如 Comparator接口，Runnable接口. - 使用lambda表达式是有一个前后要求约束的。
方法的参数为接口类型，或者说局部变量使用调用方法，可以使用lambda也OK。 - 有且只有一个抽象方法的接口，称之为【函数式接口】。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
