多线程
概念
普通方法调用和多线程
-
程序.进程.线程
-
在操作系统中运行的程序就是进程，一个进程可以有多个线程，
-
-
进程（Process）和线程（Thread）
-
说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，就是一个静态的概念，
-
而进程则是执行程序的一次执行过程，他是一个动态的概念，是系统资源分配的单位
-
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位
-
-
注意
-
很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局
-
-
核心概念
-
线程就是独立的执行路径；
-
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
-
main()称之为主线程，为系统的入口，用于执行整个程序；
-
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
-
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
-
线程会带来额外的开销，如cpu调度时间，并发控制开销。
-
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
-
线程创建
Thread
-
自定义线程类继承Thread
-
重写run（）方法，编写线程执行体
-
创建线程对象，调用start（）方法启动线程
注意：线程不一定立即执行，CPU安排调度
package com.Thread;
//创建线程方式1：继承Thread，重写run方法，调用start方法
public class TestThread1 extends Thread{
练习：使用多线程下载图片
package com.Thread;
import com.Gui.lesson04.TestTextDemo02;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread {
private String url;//网络图片地址
private String name;//保存的文件名
public TestThread2(String url,String name){
this.url = url;
this.name = name;
}
//下载图片线程的执行体
Runnable
-
定义MyRunable类实现Runnable接口
-
实现run()方法，编写线程执行体
-
创建线程对象，调用start()方法启动线程
-
推荐使用Runable对象，因为java单继承的局限性
package com.Thread;
//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{
小结
-
继承Thread类
-
子类继承Thread类具备多线程能力
-
启动线程：子类对象.start()
-
不建议使用：避免OOP单继承局限性
-
-
实现Runnable接口
-
实现接口Runnable具有多线程能力
-
启动线程：传入目标对象+Thread对象.start()
-
推荐使用：避免单继承的局限性，灵活方便，方便同一对象被多个线程使用
-
Callable接口（了解即可）
-
实现Callable接口，需要返回值类型
-
重写call方法，需要抛出异常
-
创建目标对象
-
创建执行服务：ExecutorService ser=Executors.newFixefThreadPool(1)
-
提交执行:Future<Boolean>result1=ser.submit(t1)
-
获取结果:boolean r1=result1.get()
-
关闭服务：ser.shutdownNow();
演示：利用callable改造下载图片案例
package com.Thread.demo02;
import com.Thread.demo01.TestThread2;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
//线程创建方式三：实现callable接口
public class TestCallable implements Callable<Boolean> {
private String url;//网络图片地址
private String name;//保存的文件名
public TestCallable(String url,String name){
this.url = url;
this.name = name;
}
//下载图片线程的执行体
并发
多个线程操作同一资源的情况下，线程不安全，数据紊乱，容易引起并发；
package com.Thread;
//多个线程同时操作同一个对象
//买火车票的例子
//发现问题：多个线程操作同一资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{
private int ticketNums = 10;
案例：龟兔赛跑
package com.Thread;
//模拟龟兔赛跑
public class Race implements Runnable{
//胜利者
private static String winner;
静态代理
-
真实对象和代理对象都要实现同一个接口
-
代理对象要代理真实角色
package com.Thread.demo02;
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{
//真是角色
Lamda表达式
-
λ希腊字母表排序第十一位的字母，英文名称为Lambda
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
-
为什么要使用lambda表达式
-
避免匿名内部类定义过多
-
可以让你的代码看起来简洁
-
去掉了一堆没有意义的代码，只留下核心的逻辑
-
-
函数式接口的定义
-
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
-
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
-
package com.Thread.demo0;
//推导Lambda表达式
public class TestLambda1 {
//静态内部类
static class Like2 implements ILike{
线程的五大状态
线程方法
停止线程
-
不推荐使用JDK提供的stop()、destroy()方法。
-
推荐线程自己停下来
-
建议使用一个标志位进行终止变量当flag=false，则终止线程进行。
package com.Thread.state;
//测试stop
//1.建议线程正常停止--->利用次数，不建议死循环
//2.建议使用标志位--->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
//1.设置一个标识位
private boolean flag = true;
线程休眠
-
sleep（时间）指定当前线程阻塞的毫秒数；
-
sleep存在异常InterruptedException
-
sleep时间达到后线程进入就绪状态
-
sleep可以模拟网络延时，倒计时等
-
每一个对象都有一个锁，sleep不会释放锁；
package com.Thread.state;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSleep2 {
public static void main(String[] args) {
//打印当前系统时间
Date date = new Date(System.currentTimeMillis());
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
date = new Date(System.currentTimeMillis());//更新时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//模拟倒计时
public static void tenDowm()throws InterruptedException{
int num = 10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
if (num<=0){
break;
}
}
}
}
线程礼让
-
礼让线程，让当前正在执行的线程暂停，但不阻塞
-
将线程从运行状态转为就绪状态
-
让cpu重新调度，礼让不一定成功！看CPU心情
package com.Thread.state;
//测试礼让
public class TestYield {
public static void main(String[] args) {
MyYidle myYidle = new MyYidle();
new Thread(myYidle,"a").start();
new Thread(myYidle,"b").start();
}
}
class MyYidle implements Runnable{
线程强制执行Join
-
Join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
-
可以想象成插队
package com.Thread.state;
public class TestJoin {
public static void main(String[] args)throws InterruptedException {
MyJoin myJoin = new MyJoin();
Thread thread=new Thread(myJoin);
thread.start();
//主线程
for (int i = 0; i < 1000; i++) {
if (i==200){
thread.join();//插队
}
System.out.println("main"+i);
}
}
}
class MyJoin implements Runnable{
线程状态观测
-
Thread.State
线程状态。线程可以处于以下状态之一：
-
NEW
尚未启动的线程处于此状态
-
RUNNABLE
在Java虚拟机中执行的线程处于此状态
-
BLOCKED
被阻塞等待监视器锁定的线程处于此状态
-
WAITING
正在等待另一个线程执行特定动作的线程处于此状态
-
TIMED WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
-
TERMINATED
已退出的线程处于此状态
-
一个线程可以在给定时间点处于一个状态。这些状态是不反应任何操作系统状态的虚拟机状态。
package com.Thread.state;
//观测线程状态
public class TestState {
public static void main(String[] args) {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("李成杰很帅");
});
//观测状态
Thread.State state = thread.getState();
System.out.println(state);
//观测启动后
thread.start();//启动线程
state = thread.getState();
System.out.println(state);
while (state!=Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
state = thread.getState();//更新线程状态
System.out.println(state);//输出状态
}
}
}
线程的优先级
-
Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
-
线程的优先级用数字表示，范围从1~10.
-
Thread.MIN_PRIORITY=1;
-
Thread.MAX_PRIORITY=10;
-
Thread.NORM_PRIORITY=10;
-
-
使用以下方式改变或获取优先级
-
getPriority().setPriority(int xxx)
-
package com.Thread.state;
//测试线程的优先级
public class TestPrionity {
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(10);
t4.start();
t5.setPriority(Thread.MAX_PRIORITY);
t5.start();
t6.setPriority(-1);
t6.start();
}
}
class MyPriority implements Runnable{
优先级低只是以为着获得调度的概率低，并不是优先级低就不会杯调用了。这都是看CPU的调度
守护（daemon）线程
-
线程分为用户线程和守护线程
-
虚拟机必须确保用户线程执行完毕
-
虚拟机不用等待守护线程执行完毕
-
如后台记录操作日志，监控内存，垃圾回收等待
package com.Thread.state;
//测试守护线程
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{
线程同步
-
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用
-
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问是的正确性，在访问时加入锁机制，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：
-
一个线程持有锁会导致其他所有需要此锁的线程挂起；
-
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
-
如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题
-
三大不安全案例
-
不安全买票
package com.Thread.syn;
//线程不安全 有-1
//不安全的买票
public class UnsafeBuyTickt {
public static void main(String[] args) {
ByTickt byTickt = new ByTickt();
new Thread(byTickt,"苦逼的我").start();
new Thread(byTickt,"牛逼的你").start();
new Thread(byTickt,"黄牛").start();
}
}
class ByTickt implements Runnable{
//票
private int ticketNums=10;
boolean flag=true;//外部停止方式
-
不安全取钱
package com.Thread.syn;
//不安全的取钱
//两个人去银行取钱，银行需要有账户
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, "女友");
you.start();
girlfriend.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 deawingMoney;
//现在手里多少钱
int nowMiney;
public Drawing(Account account,int deawingMoney,String name){
super(name);
this.account=account;
this.deawingMoney=deawingMoney;
}
//取钱
-
不安全线程集合
package com.Thread.syn;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
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将会影响速率
private synchronized void buy() throws InterruptedException {
//判断是否有票
if(ticketNums<=0){
flag=false;
return;
}
//模拟延时
Thread.sleep(200);
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
}
}
同步块
-
同步块：synchronized（Obj）{}
-
Obj称之为同步监视器
-
Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
-
同步方法中无须指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class【反射中讲解】
-
-
同步监视器的执行过程
-
第一个线程访问，锁定同步监视器，执行其中代码
-
第二个线程访问，发现同步监视器被锁定，无法访问
-
第一个线程访问完毕，解锁同步监视器
-
第二个线程访问，发现同步监视器没有锁，然后锁定并访问
-
//锁的对象是变化的量
synchronized (account){
//判端有没有钱
if (account.money-deawingMoney<0){
System.out.println(Thread.currentThread().getName()+"余额不足");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额=余额-你去的钱
account.money=account.money-deawingMoney;
//你手里的钱
nowMiney=nowMiney+deawingMoney;
System.out.println(account.name+"余额为"+account.money);
//Thread.currentThread().getName()==this.getName()
System.out.println(this.getName()+nowMiney);
}
}
死锁
-
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
package com.Thread.syn;
//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
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 girlNmae;//使用化妆品的人
Makeup(int choice, String girlNmae) {
this.choice = choice;
this.girlNmae = girlNmae;
}
死锁的避免方法
-
产生死锁的四个必要条件：
-
互斥条件：一个资源每次只能被一个进程录用
-
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
-
不剥夺条件：进程以获得的资源，在未使用完之前，不能强行剥夺
-
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件，我们只要办法破其中任何一个或多个条件就可以避免死锁发生
-
Lock（锁）
-
JDK5.0开始，Java提供了更强大的线程同步机制，通过显示定义同步锁对象来实现同步，同步锁使用Lock对象充当
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具，锁提供了对共享资源的独占访问，每次只能由一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
-
ReentrantLock类实现了Lock，它拥有与sunchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁。
package com.Thread.gaoji;
import java.util.concurrent.locks.ReentrantLock;
//测试类
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable{
int tickeNums = 10;
//定义可重复锁
private final ReentrantLock lock=new ReentrantLock();
synchronized与Lock的对比
-
Lock是显示锁（手动开启和关闭，别忘关闭）synchronized是隐式锁，出了作用域自动释放
-
Lock只有代码块锁，synchronized有代码块锁和方法锁
-
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
-
优先使用顺序：
-
Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）
-
线程协作
生产者消费者模式
线程通信-分析
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
-
对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
-
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
-
在生产者消费者问题中，仅有synchronized是不够的
-
synchronized可阻止并发更新同一个共享资源，实现了同步
-
synchronized不能用来实现不同线程之间的消息传递（通信）
-
package com.Thread.gaoji;
//测试生产者消费者模型->利用缓冲区解决：管程法
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;
}
//生产