多线程
一、Process与Thread
程序:程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
进程:执行程序的一次执行过程,它是一个动态的概念。是系统资源分配的单位。
线程:一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的单位。
多线程:多条执行路径,主线程与子线程并行交替执行(普通方法只有主线程一条路径)。
注意:
很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器。如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错局。
核心概念:
-
线程就是独立的执行路径
-
在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程(用户线程,main),GC线程(垃圾回收线程,守护线程)
-
main()称之为主线程,为系统的入口,用于执行整个程序
-
在一个进程中,如果开辟了多个线程,线程的运行是由调度器(cpu)安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
-
对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
-
线程会带来额外的开销,如CPU调度时间,并发控制开销
-
每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
二、线程创建
三种方式:
-
继承Thread类(重点)
-
实现Runnable接口(重点)
-
实现Callable接口(了解)
2.1 Thread类
-
自定义线程类继承
Thread
类 -
重写
run()
方法,编写线程执行体 -
创建线程对象,调用
start()
方法启动线程package com.Wuh_DFX.demo01; //线程开启不一定立即执行,由CPU安排调度 public class TestThread1 extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("run方法线程--"+i); } } public static void main(String[] args) { //main线程,主线程 //创建一个线程对象 TestThread1 thread1 = new TestThread1(); //调用start()方法开启线程 thread1.start(); for (int i = 0; i < 2000; i++) { System.out.println("主线程--"+i); } } //运行结果并发执行,穿插打印 }
案例:下载图片
package com.Wuh_DFX.demo01; 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; } //下载图片线程的执行体 @Override public void run() { WebDownloader webDownloader = new WebDownloader(); webDownloader.downloader(url,name); System.out.println("下载了文件名为:"+name); } public static void main(String[] args) { TestThread2 thread1 = new TestThread2("https://","1.jpg"); TestThread2 thread2 = new TestThread2("https://","2.jpg"); TestThread2 thread3 = new TestThread2("https://","3.jpg"); thread1.start(); thread2.start(); thread3.start(); //结果并没有按顺序执行,且每次运行结果不一样 } } //下载器 class WebDownloader{ //下载方法 public void downloader(String url,String name){ try { FileUtils.copyURLToFile(new URL(url),new File(name)); } catch (IOException e) { e.printStackTrace(); System.out.println("io异常,downloader方法出现问题"); } } }
2.2 Runnable接口
1. 自定义线程类实现`Runnable`接口
2. 实现`run()`方法,编写线程执行体
3. 创建线程对象,调用`start()`方法启动对象
package com.Wuh_DFX.demo01;
//方式2:implements Runnable 与继承Thread很像
public class TestThread3 implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("run方法线程--"+i);
}
}
public static void main(String[] args) {
//创建Runnable接口的实现类对象
TestThread3 testThread3 = new TestThread3();
//创建线程对象,通过线程对象来start()开启线程,代理
Thread thread = new Thread(testThread3);
thread.start();
//或 new Thread(testThread3).start();
for (int i = 0; i < 1000; i++) {
System.out.println("主线程--"+i);
}
}
}
- 继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程:子类对象.start()
- 不建议使用:避免OOP单继承局限性
- 实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程:传入目标对象+Thread对象.start()
- 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
案例:买火车票
package com.Wuh_DFX.demo01;
//多个线程同时操作一个对象
public class TestThread4 implements Runnable{
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true){
if(ticketNums<=0)
break;
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
TestThread4 ticket = new TestThread4();
new Thread(ticket,"小明").start();
new Thread(ticket,"老师").start();
new Thread(ticket,"黄牛党").start();
}
//发现并发问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱
}
案例:龟兔赛跑
package com.Wuh_DFX.demo01;
//模拟龟兔赛跑
public class Race implements Runnable{
//胜利者
private static String winner;
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
//判断比赛是否结束
boolean flag=gameOver(i);
if(flag){
break;
}
System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
//模拟兔子休息
if(Thread.currentThread().getName().equals("兔子")&& i%10==0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//判断是否完成比赛
private boolean gameOver(int steps){
if(winner!=null){ //已经存在胜利者
return true;
}{
if (steps==100){
winner=Thread.currentThread().getName();
System.out.println("winner is"+winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
2.3 Callable接口
-
实现Callable接口,需要返回值类型
-
重写call方法,需要抛出异常
-
创建目标对象
-
创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
-
提交执行:Future result1 = ser.submit(t1);
-
获取结果:boolean r1 = result1.get()
-
关闭服务:ser.shutdownNow();
改写例子:下载图片
package com.Wuh_DFX.demo01;
import java.util.concurrent.*;
public class TestCallable implements Callable<Boolean> {
private String url;//网络图片地址
private String name;//报错扥文件名
//有参构造
public TestCallable(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片线程的执行体
public Boolean call() throws Exception {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url, name);
System.out.println("下载了文件名为:" + name);
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestCallable c = new TestCallable("https://", "1.png");
TestCallable c1 = new TestCallable("https://", "2.png");
TestCallable c2 = new TestCallable("https://", "3.png");
//创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> r = ser.submit(c);
Future<Boolean> r1 = ser.submit(c1);
Future<Boolean> r2 = ser.submit(c2);
//获取结果
boolean res = r.get();
boolean res1 = r1.get();
boolean res2 = r2.get();
System.out.println(res);
System.out.println(res1);
System.out.println(res2);
//关闭服务
ser.shutdownNow();
}
}
//class WebDownloader在前面下载图片已经定义了,这里就不用再次写,直接使用就好
实现callable接口的好处
1.可以定义返回值
2.可以抛出异常
2.4 静态代理
演示:实现静态代理对比Thread
package com.Wuh_DFX.demo02;
public class StaticProxy {
public static void main(String[] args) {
/*You you = new You();
you.HappyMarry();*/ //原本方式,下面交给代理
//线程类代理,实际调用了Runnable接口中的run方法
new Thread(()-> System.out.println("我爱你")).start();
new WeddingCompany(new you()).HappyMarry();
/*WeddingCompany company = new WeddingCompany(new You());
company.HappyMarry();
*/
}
}
interface Marry{
void HappyMarry();
}
//真实角色
class You implements Marry{
@Override
public void HappyMarry() {
System.out.println("我今天要结婚了!");
}
}
//代理角色
class WeddingCompany implements Marry{
private Marry target; //目标:真实对象
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() { //实现代理
before();
this.target.HappyMarry(); //调用真实对象的方法
after();
}
private void after() {
System.out.println("善后工作!");
}
private void before() {
System.out.println("婚前布置!");
}
}
静态代理模式总结:
1.真实对象与代理对象要实现同一接口
2.代理对象代理真实角色
好处:
1.代理对象可以做很多真实对象做不了的事情,比如布置结婚场景
2.真实对象专注做自己的事情,结婚
2.5 Lamda表达式
-
λ 希腊字母表中排序第十一位的字母,英语名称为 Lamda
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
-
去掉了一堆没有意义的代码,只留下核心逻辑
(params) -> expression[表达式]
(params) -> statement[语句]
[(params)-> {statements}
-
理解Functional Interface (函数式接口) 是学习Java8 Lamda表达式的关键
-
函数接口定义:
-
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口.
public interface Runnable{ public abstract void run(); }
-
对于函数式接口,我们可以通过Lamda表达式来创建该接口的对象.
-
案例1:
/*
* 推导Lamda表达式
*/
public class TestLamda1 {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda2");
}
}
public static void main(String[] args) {
ILike like = new Like1();
like.lamda();
like = new Like2();
like.lamda();
//4.局部内部类
class Like3 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda3");
}
}
like = new Like3();
like.lamda();
//5.匿名内部类,没有类的名称,必须借助接口或者父类
like = new ILike () {
@Override
public void lamda() {
System.out.println("I like lamda4");
}
};
like.lamda();
//6.用lamda简化
like = () ->{
System.out.println("I like lamda5");
};
like.lamda();
}
}
// 1.定义一个函数式接口
interface ILike {
void lamda();
}
// 2.实现类
class Like1 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda1");
}
}
案例2:
public class Demo14_LamdaCase2 {
public static void main(String[] args) {
// 1.lamda
ILove love = (int a) -> {
System.out.println("I love you -->" + a);
};
// 2.lamda简化1.0
love = (a) -> {
System.out.println("I love you -->" + a);
};
// 3.lamda简化2.0
love = a -> {
System.out.println("I love you -->" + a);
};
// 3.lamda简化3.0
love = a -> System.out.println("I love you -->" + a);
/**总结:
* {}简略的条件是只能有一行代码,多行{}就不能简略了
* 前提是接口为函数式接口(只能有一个方法)
* 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()
*/
love.love(520);
}
}
interface ILove {
void love(int a);
}
三、线程状态及方法
停止线程
/**
* 测试stop
* 1.建议线程正常停止-->利用次数,不建议死循环
* 2.建议使用标志位-->设置一个标志位
* 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
*/
public class Demo15_StopThread implements Runnable {
// 1. 设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag) {
System.out.println("run...Thread" + i++);
}
}
// 2. 设置一个公开的方法停止线程,转换标志位
public void stop() {
this.flag = false;
}
public static void main(String[] args) {
Demo15_StopThread stop = new Demo15_StopThread();
new Thread(stop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main..." + i);
if (i == 900) {
//调用stop()切换标志位,让线程终止
stop.stop();
System.out.println("该线程停止了");
}
}
}
}
线程休眠`/**
-
模拟网络延迟:放大问题的发生性
*/
public class Demo16_SleepThread implements Runnable {//票数
private int ticketNums = 10;@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//捕获异常
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “—>拿到了第” + ticketNums-- + “张票”);
}
}public static void main(String[] args) {
Demo4_TrainTicketsCase ticket = new Demo4_TrainTicketsCase();
new Thread(ticket, “小红”).start();
new Thread(ticket, “老师”).start();
new Thread(ticket, “黄牛1”).start();
}
}
`线程礼让
/**
* 测试礼让线程
* 礼让不一定成功,看cpu心情
*/
public class Demo19_YieldThread {
public static void main(String[] args) {
MyYeild myYeild = new MyYeild();
new Thread(myYeild, "a").start();
new Thread(myYeild, "b").start();
}
}
class MyYeild implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程开始执行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName() + "线程停止执行");
}
}
线程插队
/**
* 测试join
* 插队
*/
public class Demo20_JoinThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 500; i++) {
System.out.println("线程vip" + i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
Demo20_JoinThread joinThread = new Demo20_JoinThread();
Thread thread = new Thread(joinThread);
thread.start();
//主线程
for (int i = 0; i < 500; i++) {
if (i == 200) {
thread.join();//插队
}
System.out.println("main" + i);
}
}
}
线程状态观测
/**
* 观察测试线程状态
*/
public class Demo21_ThreadState {
public static void main(String[] args) throws InterruptedException {
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);//Run
while (state != Thread.State.TERMINATED) {//只要现成不终止,就一直输出状态
Thread.sleep(100);
state = thread.getState();//更新线程状态
System.out.println(state);
}
//死亡后的线程不能再启动了,启动会报异常
//thread.start();
}
}
线程优先级
/**
* 线程优先级
*/
public class Demo22_ThreadPriority{
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread thread1 = new Thread(myPriority);
Thread thread2 = new Thread(myPriority);
Thread thread3 = new Thread(myPriority);
Thread thread4 = new Thread(myPriority);
Thread thread5 = new Thread(myPriority);
//先设置优先级,再启动
thread1.start();
thread2.setPriority(1);
thread2.start();
thread3.setPriority(4);
thread3.start();
thread4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
thread4.start();
thread5.setPriority(8);
thread5.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护(daemon)线程
/**
* 测试守护线程
* 上帝守护你
*/
public class Demo23_DaemonThread {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
//默认false表示是用户线程,正常的线程都是用户线程...
thread.setDaemon(true);
//上帝守护线程启动
thread.start();
//你 用户线程启动
new Thread(you).start();
}
}
//上帝
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保佑着你");
}
}
}
//你
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你一生都开心的活着");
}
System.out.println("====goodbye!world====");
}
}
线程同步·
不安全的线程案例`//不安全买票
public class Demo24_UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket, “张三”).start();
new Thread(buyTicket, “李四”).start();
new Thread(buyTicket, “王五”).start();
}
}
class BuyTicket implements Runnable {
//票
private int ticketNums = 10;
boolean flag = true;
@Override
public void run() {
//买票
while (flag) {
try {
buy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
//买票
private void buy() {
//判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
//延迟
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
`同步方法
//安全买票
public class Demo27_SafeBuyTicket {
public static void main(String[] args) {
BuyTicket1 buyTicket = new BuyTicket1();
new Thread(buyTicket, "张三").start();
new Thread(buyTicket, "李四").start();
new Thread(buyTicket, "王五").start();
}
}
class BuyTicket1 implements Runnable {
//票
private int ticketNums = 10;
boolean flag = true;
@Override
public void run() {
//买票
while (flag) {
try {
buy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
//synchronized 同步方法,锁的是this
private synchronized void buy() {
//判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
//延迟
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
死锁
/**
* 死锁:多个线程互相抱着对方需要的资源,然后形成僵持
* 解决:一个锁只锁一个对象
*/
class Demo31_DeadLock {
public static void main(String[] args) {
Makeup makeup = new Makeup(0, "灰姑娘");
Makeup makeup1 = new Makeup(1, "白雪公主");
makeup.start();
makeup1.start();
}
}
//口红
class Lipstick { }
//镜子
class Mirror { }
class Makeup extends Thread {
//需要的资源只有一份,用static保证只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;//选择
String girlName;//使用化妆品的人
public Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {//获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
synchronized (mirror) {//一秒钟后想获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
}
} else {
synchronized (mirror) {//获得口红镜子
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(2000);
synchronized (lipstick) {//二秒钟后想获得的锁
System.out.println(this.girlName + "获得口红的锁");
}
}
}
}
}
Lock(锁)
//测试Lock锁
public class Demo32_ThreadLock {
public static void main(String[] args) {
TestLock testLock = new TestLock();
new Thread(testLock).start();
new Thread(testLock).start();
new Thread(testLock).start();
}
}
class TestLock implements Runnable {
int tickerNums = 10;
//定义Lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
//加锁
try {
lock.lock();
if (tickerNums <= 0) {
break;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tickerNums--);
} catch (Exception e) {
e.printStackTrace();
} finally {
//解锁
lock.unlock();
}
}
}
}
五 .线程通信方法
/**
* 测试:生产者消费者模型-->利用缓冲区解决:管程法
*/
public class Demo33_ThreadPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Producer(synContainer).start();
new Consumer(synContainer).start();
}
}
//生产者
class Producer extends Thread {
//容缓冲区
SynContainer container;
public Producer(SynContainer container) {
this.container = container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
container.push(new Product(i));
System.out.println("生产了" + i + "件产品");
}
}
}
//消费者
class Consumer extends Thread {
//容缓冲区
SynContainer container;
public Consumer(SynContainer container) {
this.container = container;
}
//消费
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了-->" + container.pop().id + "件产品");
}
}
}
//产品
class Product {
int id;//产品编号
public Product(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer {
//需要一个容器大小
Product[] products = new Product[10];
//容器计数器
int count = 0;
//生产者放入产品
public synchronized void push(Product product) {
//如果容器满了,需要等待消费者消费
/*如果是if的话,假如消费者1消费了最后一个,这是index变成0此时释放锁被消费者2拿到而不是生产者拿到,这时消费者的wait是在if里所以它就直接去消费index-1下标越界,如果是while就会再去判断一下index得值是不是变成0了*/
while (count == products.length) {
//通知消费者消费,等待生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有满,需要丢入产品
products[count] = product;
count++;
//通知消费者消费
this.notifyAll();
}
//消费者消费产品
public synchronized Product pop() {
//判断是否能消费
while (count <= 0) {
//等待生产者生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果可以消费
count--;
Product product = products[count];
//吃完了 通知生产者生产
this.notifyAll();
return product;
}
}
六、线程池
//测试线程池
public class Demo35_ThreadPool {
public static void main(String[] args) {
// 1. 创建服务,擦行间线程池
// newFixedThreadPool(线程池大小)
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭连接
service.shutdown();
}
}
class MyThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}