大家好，又见面了，我是你们的朋友全栈君。
-
现实中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。
多线程
-
原来是一条路，慢慢因为车太多了，道路堵塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道。从此，妈妈再也不用担心道路堵塞了。
普通方法调用和多线程
程序、进程、线程
-
在操作系统中运行的程序就是进程，比如你的QQ、播放器、游戏、IDE等等
-
一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等。
Process与Thread
-
说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
-
而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
-
通常在一个进程中可以包含若干线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
-
【注意】：很多多线程是模拟出来的，真正的多线程是指由多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快了，很快就有同时执行的错觉。
核心概念
-
线程就是独立的执行路径；
-
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程（垃圾回收）；
-
main()称之为主线程，为系统的入口，用于执行整个程序；
-
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为是干预的。
-
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
-
线程会带来额外的开销，如cpu调度时间，并发控制开销。
-
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。
线程的三种创建方式
Thread
-
自定义线程类继承Thread类
-
重写run()方法，编写线程执行体
-
创建线程对象，调用start()方法启动线程
-
【注意】：线程开启不一定立即执行，由CPU安排调度。
实现Runnable
-
定义MyRunnable类实现Runnable接口
-
实现run()方法，编写线程执行体
-
创建线程对象，调用start()方法启动线程
-
推荐使用Runnable对象，因为Java单继承的局限性
小结
-
继承Thread类
-
子类继承Thread类具备多线程能力
-
启动线程：子类对象.start()
-
不建议使用：避免OOP单继承局限性
-
-
实现Runnable接口
-
实现接口Runnable具有多线程能力
-
启动线路：传入目标对象+Thread对象.start()
-
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
-
//多个线程同时操作同一个对象
//买火车票的例子
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。
public calss TestThread4 implements Runnable{
//票数
priate int ticketNum = 10;
案例
-
首先来个赛跑距离，然后要离终点越来越近
-
判断比赛是否结束
-
打印出胜利者
-
龟兔赛跑开始
-
故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟兔子睡觉
-
终于，乌龟赢得比赛
//模拟龟兔赛跑
public class Race implements Runnable{
//胜利者
private static String winner; //保证只有一个winner
实现Callable接口（了解）
-
实现Callable接口，需要返回值类型
-
重写call方法，需要抛出异常
-
创建目标对象
-
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
-
提交执行：Future<Boolean> result1 = ser.submit(t1);
-
获取结果：boolean r1 = result1.get();
-
关闭服务：ser.shutdownNow();
Lamda表达式
-
希腊字母表中排序第十一位的字母，英文名称为Lamda
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
(params) -> expression[表达式]
(params) -> statment[语句]
(params) -> {statments}
a -> System.out.println("i like lambda-->"+a);
new Thread(()->System.out.println("多线程学习。。")).start(); -
为什么要使用Lamda表达式
-
避免匿名内部类定义过多
-
可以让你的代码看起来很简洁
-
去掉了一堆没用意义的代码，只留下核心的逻辑。
-
-
理解Functional Interface （函数式接口）是学习Java8 Lamda表达式的关键所在。
-
函数式接口的定义：
-
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
public interface Runnable{
public absrtact void run();
} -
对于函数式接口，我们可以通过Lamda表达式来创建该接口的对象。
-
-
一步一步简化==>
-
==>继续
-
==>主角登场啦
-
还可以简化呀！
-
总结：
-
lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
-
前提是接口为函数式接口
-
多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。
-
静态代理
-
你：真实角色
-
婚庆公司：代理你，帮你处理结婚的事
-
结婚：实现结婚接口即可
public class StaticProxy{
public static void main(String[] args){
You you = new You(); //你要结婚
/*
WeddingCompany weddingCompany = new WeddingCompany(you);
weddingCompany.HappyMarry();
*/
new Thread( ()->System.out.println("我爱你") ).start();
new WeddingCompany(new You()).HappyMerry();
/*
Runnable接口和Thread代理都有run方法，最后调用的事Thread的start方法，但实际执行的还 是Runnable中的run方法的方法体
这句话说出来就明白了：婚礼公司相当于thread，结婚的人相当于实现runnable接口的类。用 thread代替接口实现类做一些东西。
*/
}
}
interface Marry{
void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{
-
静态代理模式总结：
-
真实对象和代理对象都要实现同一个接口
-
代理对象要代理真实角色
-
-
好处：
-
代理对象可以做很多真实对象做不了的事情
-
真实对象专做自己的事情
-
线程状态
停止线程
-
不推荐使用JDK提供的stop()、destory()方法。【已废弃】
-
推荐线程自己停下来
-
建议使用一个标志位进行终止变量。当flag=false，则种植者线程运行。
public class TestStop implements Runnable{
//1.设置一个标志位
private boolean flag = true;
-
可能bug：
-
线程进入while循环体内
-
main线程执行stop方法切换标志位并输出
-
线程执行while方法体的输出
-
所以会产生线程多输出一次的现象。
-
线程休眠
-
sleep(时间)指定当前线程阻塞的毫秒数。；
-
sleep存在异常InterruptedException；
-
sleep时间达到后线程进入就绪状态；
-
sleep可以模拟网络延时，倒计时等。
-
每一个对象都有一个锁，sleep不会释放锁；
public static void main(String[] args){
try{
tenDown();
}catch(InterruptedException e){
e.printStaxkTrace();
}
}
//模拟倒计时
public static void tenDown() throws InterruptedException{
int num = 10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if(num<=0)
break;
}
}
线程礼让
-
线程礼让，让当前正在执行的线程暂停，但不阻塞
-
将线程从运行状态转为就绪状态
-
让cpu重新调度，礼让不一定成功！看CPU心情
//测试礼让线程
//礼让不一定成功，看CPU心情
public class TestYield{
public static void main(String[] args){
MyYield myYield = new MyYield();
new Thread(myYield,'a').start();
new Thread(myYield,'b').start();
}
}
class MyYield implements Runnable{
Join
-
Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
-
可以想象成插队
//测试Join方法--->想象成插队
public class TestJoin implements Runnabl{
观察测试线程的状态
public class void main(String[] args) throws InterruptedException{
Thread thread = new Thread( ()=>{
for(int i=0;i<5;i++){
try{
Thread.sleeo(1000);
}catch(InterruptedException e){
e.printStaxkTrace();
}
}
System.out.println("///////");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state); //NEW
//观察启动后
Thread.start(); //启动线程
state = thread.getState();
System.out.println(state); //Run
while(state != Thread.State.TERMINATED){ //只要线程不终止，就一直输出状态
Thread.sleeo(1000);
state = thread.getState(); //更新线程状态
System.out.println(state); //输出状态
}
}
【注意】：
线程不能启动两次，即死亡之后的线程就不能再启动了。
执行完了之后就““死”了，只能在new一个执行。
线程优先级
-
Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
-
线程的优先级用数字表示，范围从1~10.
-
Thread.MIN_PRIORITY = 1;
-
Thread.MAX_PRIORITY = 10;
-
Thread.NORM_PRIORITY = 5;
-
-
使用以下方式改变或获取优先级
-
get.Priority.setPriority(int xxx)
-
-
优先级高不一定会先执行，还要看CPU调度谁。只是优先级高被调度的几率大。
//测试线程的优先级
public class TestPriority{
public static void main(String[] args){
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority= new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
Thread t5 = new Thread(myPriority);
Thread t6 = new Thread(myPriority);
//先设置优先级，再启动
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(MAX_PRIORITY); //MAX_PRIORITY=10
t4.start();
t5.setPriority(-1);
t5.start();
t6.setPriority(11);
t6.start();
}
}
class MyPriority implements Runnable{
【注意】：优先级的设定建议在start()调度前
守护(daemon)线程
-
线程分为用户线程和守护线程
-
虚拟机必须确保用户线程执行完毕，如main()
-
虚拟机不用等待守护线程执行完毕，如gc()
-
如，后台记录操作日志，监控内存，垃圾回收等…
//上帝守护你
public class TestDaemon{
public static void main(String[] args){
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true); //默认是false表示是用户线程，正常的线程都是用户线程
thread.start(); //上帝守护线程启动
new Thread(you).start(); //你 用户线程启动
}
}
//上帝
class God implements Runnable{
直到你到100岁死了上帝就不守护你了。你死了上帝还在运行一会，因为虚拟机停止需要一点时间。
线程同步—多个线程操作同一个资源
并发
-
并发：同一个对象被多个线程同时操作
-
上万人同时抢100张票
-
两个银行同时取钱
线程同步
-
现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决方法就是，排队，一个个来。
-
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程使用。
队列和锁
-
队列+锁才能保证进程同步的安全性
线程同步
-
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入了锁机制Synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：
-
一个线程持有锁会导致其他所有需要此锁的线程挂起。
-
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
-
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。
-
案例一：
//不安全的买票
public class UnsafeBuyTicket{
public static void main(String[] args){
BuyTicker station = new BuyTicker();
new Thread(station,"苦逼的我").start();
new Thread(station,"牛逼的你们").start();
new Thread(station,"可恶的黄牛党").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNum = 10;
boolean flag = true; //外部停止方式
案例二：
//不安全的取钱
//两个人去一行取钱，账户
public class UnsafeBank{
public static void main(String[] args){
//账户
Account account = new Account(100,"结婚基金");
Drawing you = new Drawing(account,50,"你");
Drawing girlFriend = new Drawing(account,100,"girlFriend");
you.start();
girlFrined.start();
}
}
//账户
class Account{
int money; //余额
String name; //卡名
public Account(int money,String name){
this.money = money;
this.name =name;
}
}
//银行：模拟取款
class Drawing extends Thread{
Account account; //账户
int drawingMoney; //取了多少钱
int nowMoney; //现在手机有多少钱
public Drawing(Account account,int drawingMone,String name){
super(name);
this.account = account;
this.drawingMone = drawingMone;
}
//取钱
案例三：
//线程不安全的集合
public class UnsafeList{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
for(int i=0;i<10000;i++){
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
//sleep可以方法问题的发生性
try{
Thread.sleep(3000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(list.size());
}
}
可能只两个线程同一瞬间操作了同一个位置，把两个数组添加到了同一个位置。就覆盖掉了，所以元素会少。
同步方法
-
由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：
synchronized方法和synchronized块。
//同步方法：
public synchronized void method(int args){} -
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个Synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大的方法申明为Synchronized将会影响效率
同步方法弊端
-
方法里面需要修改的内容才需要锁，锁的太多，浪费资源。
同步块
-
同步块：synchronized(Obj){}
-
Obj称之为同步监视器
-
Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
-
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class【反射中讲解】
-
-
同步监视器的执行过程
-
第一个线程访问，锁定同步监视器，执行其中代码。
-
第二个线程访问，发现同步监视器被锁定，无法访问。
-
第一个线程访问完毕，解锁同步监视器。
-
第二个线程访问，发现同步监视器没有锁，然后锁定并访问。
-
案例一：
//安全的买票
public class UnsafeBuyTicket{
public static void main(String[] args){
BuyTicker station = new BuyTicker();
new Thread(station,"苦逼的我").start();
new Thread(station,"牛逼的你们").start();
new Thread(station,"可恶的黄牛党").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNum = 10;
boolean flag = true; //外部停止方式
都是一个人的，syn关键字有偏向于最先获得锁的线程更高的优先级，你需要在调用buy方法前后让他休眠一会，让给别人。
案例二：
//安全取钱
public class UnsafeBank{
public static void main(String[] args){
//账户
Account account = new Account(100,"结婚基金");
Drawing you = new Drawing(account,50,"你");
Drawing girlFriend = new Drawing(account,100,"girlFriend");
you.start();
girlFrined.start();
}
}
//账户
class Account{
int money; //余额
String name; //卡名
public Account(int money,String name){
this.money = money;
this.name =name;
}
}
//银行：模拟取款
class Drawing extends Thread{
Account account; //账户
int drawingMoney; //取了多少钱
int nowMoney; //现在手机有多少钱
public Drawing(Account account,int drawingMone,String name){
super(name);
this.account = account;
this.drawingMone = drawingMone;
}
//取钱
//1.并不是在run()上加synchronized：这里为什么出现了不同步的情况，是因为，创建这个银行账户多线程的方式是继承Thread，也就是通过extends Thread来进行实现的，在main主方法中。线程“you”执行run方法时发现加锁了，便找到加锁对象(you)，发现没有其他线程执行run方法，就持锁执行run方法，线程“girlfriend”执行run方法时发现加锁了，便找到枷锁对象(girlfriend,不是you)，也发现没有其他线程执行run方法，就持锁执行run方法。------>锁银行是没用的！<----synchronized默认锁的是this
案例三：
//线程安全的集合
public class UnsafeList{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
for(int i=0;i<10000;i++){
new Thread(()->{
synchronized(list){ //只改了这里
list.add(Thread.currentThread().getName());
}
}).start();
}
//sleep可以方法问题的发生性
try{
Thread.sleep(3000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(list.size());
}
}
不加sleep是因为其它线程还在运行中，主线程提前跑完了，导致显示的结果小于10000。
不用sleep锁不住的原因是因为线程执行太快，其他线程没执行，车票都抢完了，你把车票设置多些就好了。
补充JUC
//测试JUC安全类型的集合
import java.util.concurrent.CopyOnWriteArrayList;
public class TestJUC{
public static void main(String[] args){
//CopyOnWirteArrayList这个类本来就是安全的，咱直接拿过来用
CopyOnWirteArrayList<String> list new CopyOnWirteArrayList<String>();
for(int i=0;i<10000;i++){
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
//for外面休眠,是为了让主线程休眠
try{
Thread.sleep(3000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(list.size());
}
}
个人理解：创建了线程要等CPU去调度才能执行，即lambda表达式里边的东西，这个时候若循环次数结束了，主函数即将输出sout函数，可能有些new线程没被cup调度，所以也就没有add进去，就被打印了。
死锁
-
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情况。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
//死锁:多个线程互相抱着对方需要的资源，然后形成死锁
//解决死锁
public class DeacLock{
public static void main(String[] args){
Makeup g1 = new Makeup(0,"灰姑凉");
Makeup g2 = new Makeup(1,"白雪公主");
g1.start();
g2.start();
}
}
//口红
class Lipstick{
}
//镜子
class Mirror{
}
class Makeup extends Thread{
//需要的资源只有一份，用static来保证只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice; //选择
String girlName; //使用化妆品的人
Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
同步块的锁。同步块结束了就释放锁。只要有一个释放了锁 就不会变成死锁。
死锁避免方法
-
产生死锁的四个必要条件：
-
互斥条件：一个资源每次只能被一个进程使用。
-
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
-
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
-
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
-
-
上面列出了锁的四个必要条件，我们只要想办法破坏其中的任意一或多个条件就可以避免死锁的发生。
Lock(锁)
-
从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
-
ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在现实线程安全的控制中，比较常用的事ReentrantLock，可以显示加锁、释放锁。
//测试Lock锁
public class TestLock{
public static void main(String[] args){
TestLock2 testLock2 = new TestLock2():
//3个线程同时操作一个对象
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable{
int ticketNums = 10;
这样不安全！
//解决方法：
public class TestLock{
public static void main(String[] args){
TestLock2 testLock2 = new TestLock2():
//3个线程同时操作一个对象
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable{
int ticketNums = 10;
//定义lock锁 ---加private是为了保证安全
private final ReentrantLock lock = new ReentrantLock();
synchronized与Lock对比
-
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。
-
Lock只有代码块锁，synchronized有代码块锁和方法锁。
-
使用Lock锁，JVM将花费较少时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）。
-
优先使用顺序：
-
Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）
-
线程协作
线程通信
-
应用场景：生产者和消费者问题
-
假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
-
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的从产品被消费者取走为止。
-
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。
-
线程通信-分析
-
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。
-
对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费。
-
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
-
在生产者消费者问题中，仅有synchronized是不够的
-
synchronized可组织并发更新同一个共享资源，实现了同步
-
synchronized不能用来实现不同线程之间的消息传递（通信）
-
-
-
Java提供了几个方法解决线程之间的通信问题
sleep不会释放锁，wait会释放锁
-
【注意】：均是Object类的方法，都只能在同步方法或者同步代码块中使用，斗则会抛出异常IllegalMonitorStateException
解决方式1
-
并发协作模型“生产者/消费者模式”—>管程法
-
生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
-
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
-
缓冲区：不能直接使用生产者的数据，他们之间有个“缓冲区”
-
-
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
解决方式2
-
并发协作模型“生产者/消费者模式”—>信号灯法
管程法
//生产者消费者模型-->利用缓冲区解决：管程法
//需要的四个对象：生产者，消费者，产品，缓冲区
public class TestPC{
public static void main(String[] args){
SynContainer container = new SynContainer();
new Productor(container).start();
new Consumer(container).start();
}
}
//生产者
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
//生产