//输出
我在学习–0
我在学习–1
我在学习–2
我在学习–3
我在学习–4
我在撸代码–0
我在学习–5
我在撸代码–1
我在学习–6
我在撸代码–2
我在撸代码–3
我在学习–7
我在学习–8
我在学习–9
我在撸代码–4
我在撸代码–5
我在撸代码–6
我在撸代码–7
我在撸代码–8
我在撸代码–9
继承Thread类
1.子类继承Thread 类具有多线程能力
2.启动线程:子类对象.start()
3.不建议使用:避免OOP单继承局限性
实现Runnable 接口
1.实现接口Runnable 具有多线程能力
2.启动线程:传入目标对象+Thread对象.start()
3.推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
1.首先来个赛道距离,然后要离终点越来越近
2.判断比赛是否结束
3.打印出胜利者
4.龟兔赛跑开始
5.故事中是乌龟赢了,兔子需要睡觉,所以我们模拟兔子睡觉
6.终于,乌龟赢了
package cn.bloghut.thread;
/**
-
@author by 闲言
-
@classname Race
-
@description 模拟龟兔赛跑
-
@date 2021/7/27 19:13
*/
public class Race implements Runnable {
//胜利者
private static String winner;
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
//模拟兔子休息
if (Thread.currentThread().getName().equals(“兔子”) || i % 10 == 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(i);
//如果比赛结束了,就停止程序
if (flag) {
break;
}
System.out.println(Thread.currentThread().getName() + “–>跑了” + i + “步”);
}
}
//判断是否完成比赛
private boolean gameOver(int steps) {
if (winner != null) {//已经由胜利者了
return true;
} else {
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();
}
}
//结果
Winner is 乌龟
创建线程方式3:实现Callable 接口
1.实现Callable接口,需要返回值类型
2.重写call 方法,需要抛出异常
3.创建目标对象
4.创建执行服务:
5.提交执行:
6.获取结果:
7.关闭服务:
package cn.bloghut.callable;
import cn.bloghut.thread.TestThread2;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
/**
-
@author by 闲言
-
@classname TestCallable
-
@description 线程创建方式三:实现Callable即可
-
@date 2021/7/29 12:03
*/
public class TestCallable implements Callable {
private String url;//网络图片地址
private String name;//保存的文件名
public TestCallable(String url, String name) {
this.name = name;
this.url = url;
}
//下载图片线程的执行体
@Override
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 t1 = new TestCallable(“https://img-blog.csdnimg.cn/img_convert/d8885c9a178b2fcaea732190717b516d.png”, “1.jpg”);
TestCallable t2 = new TestCallable(“https://img-blog.csdnimg.cn/img_convert/d8885c9a178b2fcaea732190717b516d.png”, “2.jpg”);
TestCallable t3 = new TestCallable(“https://img-blog.csdnimg.cn/img_convert/d8885c9a178b2fcaea732190717b516d.png”, “3.jpg”);
//1.创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//2.提交执行
Future r1 = ser.submit(t1);
Future r2 = ser.submit(t2);
Future r3 = ser.submit(t3);
//获取结果
Boolean rs1 = r1.get();
Boolean rs2 = r2.get();
Boolean rs3 = r3.get();
//关闭服务
ser.shutdownNow();
}
}
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方法出现问题”);
}
}
}
静态代理总结:
1.真实对象和代理对象都要实现同一个接口
2.代理对象要代理真实角色
好处:
代理对象可以做很多对象做不了的事情
真实对象专注做自己的事情
package cn.bloghut.proxy;
/**
-
@author by 闲言
-
@classname StactProxy
-
@description 静态代理简单说明
-
@date 2021/7/29 12:19
*/
public class StacticProxy {
public static void main(String[] args) {
You you = new You();//你要结婚
new Thread( () -> System.out.println(“嘤嘤嘤”)).start();
new WeddingCompany(new You()).hashCode();
}
}
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(“结婚之前,布置现场”);
}
}
入 希腊字母表中排序第十一位的字母,英语名称为Lambda
避免内部类定义过多
其实质属于函数式编程概念
(params) -> expression [表达式]
(params) -> statement [语句]
(params) -> {statement }
new Thread(()-> System.out.println(“多线程学习”)).start();
为什么要使用lambda 表达式
1.避免你们内部类定义过多
2.可以让你的代码看起来很简洁
3.去掉了一堆没有意义的代码,只留下核心的逻辑
函数式接口的定义
1.任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。
2.对于函数式接口,我们可以通过lambda 表达式来创建该接口的对象。
public interface Runnable{
public abstract void run();
}
案例1
package cn.bloghut.lambda;
/**
-
@author by 闲言
-
@classname Testlambda
-
@description 推导lambda表达式
-
@date 2021/7/29 12:38
*/
public class Testlambda {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println(" i like lambda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println(" i like lambda3");
}
}
like = new Like3();
like.lambda();
//5.匿名内部类
like = new ILike() {
@Override
public void lambda() {
System.out.println(" i like lambda4");
}
};
like.lambda();
//6.用lambda表达式
like = ()->{
System.out.println(" i like lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike {
void lambda();
}
//2.实现类
class Like implements ILike {
@Override
public void lambda() {
System.out.println(" i like lambda");
}
}
线程方法
线程停止
1.建议线程正常停止----》利用次数。不建议死循环
2.建议使用标志位----》设置一个标志位
3.不用使用stop或destory 等过时或者JDK 不建议使用的方法
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestStop
-
@description 测试stop
-
@date 2021/7/29 17:51
*/
public class TestStop 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) {
TestStop testStop = new TestStop();
//开启线程
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println(“main” + i);
if (i == 900) {
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println(“该线程停止了”);
}
}
}
}
1.sleep(时间)指定当前线程阻塞的毫秒数;
2.sleep 存在异常InterruptedException;
3.sleep 时间达到后线程进入就绪状态
4.sleep 可以模拟网络延时,倒计时等。
5.每一个对象都有一个锁,sleep不会释放锁;
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestSleep
-
@description 模拟网络延时:放大问题的发生性
-
@date 2021/7/29 18:09
*/
public class TestSleep implements Runnable {
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//模拟延时
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “—>拿到了第” + ticketNums-- + “票”);
}
}
public static void main(String[] args) {
TestSleep testSleep = new TestSleep();
new Thread(testSleep,“小明”).start();
new Thread(testSleep,“小红”).start();
new Thread(testSleep,“小黄牛”).start();
}
}
案例:模拟倒计时 、打印当前系统时间
package cn.bloghut.state;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
-
@author by 闲言
-
@classname TestSleep2
-
@description 模拟倒计时
-
@date 2021/7/29 18:23
*/
public class TestSleep2 {
/**
-
模拟倒计时
-
@throws InterruptedException
*/
public static void testDown() throws InterruptedException {
int num = 10;
while (true) {
Thread.sleep(1000);
System.out.println(num–);
if (num == 0) {
break;
}
}
}
/**
- 打印当前时间
*/
public static void printNowDate() {
//打印当前系统时间
Date stattTime = new Date(System.currentTimeMillis());
while (true) {
try {
//休眠1秒
Thread.sleep(1000);
//格式化时间,并输出时间
System.out.println(new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”).format(stattTime));
//更新获取时间
stattTime = new Date(System.currentTimeMillis());
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
printNowDate();
}
}
1.礼让线程,让当前正在执行的线程暂停,但不阻塞
2.将线程从运行状态转为就绪状态
3.让cpu 重新调度,礼让不一定成功!看cpu心情
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestYied
-
@description 测试礼让线程
-
礼让不一样成功,看CPU心情
-
@date 2021/7/29 18:35
*/
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 {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+“线程开始执行”);
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+“线程停止执行”);
}
}
Join 合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
可以想象成插队
练习:
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestJoin
-
@description 测试join 方法
-
想象为插队
-
@date 2021/7/29 18:42
*/
public class TestJoin implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(“线程VIP 来了” + i);
}
}
public static void main(String[] args) throws InterruptedException {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
//启动线程
thread.start();
//主线程
for (int i = 0; i < 200; i++) {
if (i == 100) {
thread.join();//插队
}
System.out.println(“main” + i);
}
}
}
Thread.State
线程状态,线程可以处于以下状态之一:
NEW
尚未启动的线程处于此状态
RUNNABLE
在Java虚拟机中执行的线程处于此状态
BLOCKED
被阻塞等待监视器锁定的线程处于此状态
WAITING
正在等待另一个线程执行特定动作的线程处于此状态
TIMED WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINATED
已退出的线程处于此状态
一个线程可以在给定时间点处于一个状态,这些状态不反映任何操作系统线程状态的虚拟机状态。
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TeestState
-
@description 观测线程状态
-
@date 2021/7/30 10:39
*/
public class TeestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
}catch (Exception 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){
Thread.sleep(100);
state = thread.getState();//更新线程状态
System.out.println(state);//输出线程状态
}
}
}
注意:线程中断或结束,一旦进入死亡状态,就不能再次启动。
1.Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器安装优先级决定应该调度哪个线程来执行。
2.线程的优先级用数字表示,范围从1——10
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NOPM_PRIORITY = 5;
使用以下方式改变或获取优先级
getPriority()
setPriority(int xx)
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestPriority
-
@description 测试线程的优先级
-
@date 2021/7/30 10:52
*/
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(Thread.MAX_PRIORITY);//10
t4.start();
// t5.setPriority(-1);//通过查看源码发现,设置优先级为-1会报错(小于1)
// t5.start();
// t6.setPriority(11);//通过查看源码发现,设置优先级为11会报错(大于10)
//t6.start();
t5.setPriority(8);
t5.start();
t6.setPriority(7);
t6.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+“==”+Thread.currentThread().getPriority());
}
}
优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用,这都是看CPU的调度。
1.线程分为用户线程和守护线程
2.虚拟机必须确保用户线程执行完毕
3.虚拟机不用等待守护线程执行完毕
如:后台记录操作日志、监控内存、垃圾回收等等…
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestDaemon
-
@description 测试守护线程
-
@date 2021/7/30 12:14
*/
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 You implements Runnable {
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println(“你一生都开心活着”);
}
System.out.println(“===goodbye! world=”);
}
}
//上帝
class God implements Runnable {
@Override
public void run() {
while (true) {
System.out.println(“上帝保护着你”);
}
}
}
线程同步
多个线程操作同一个资源
并发:同一个对象被多个线程同时操作
现实生活中,我们会遇到“同一资源,多个人都想使用”的问题,比如:食堂排队打饭,每个人都想吃饭,最天然的解决办法就是,排队。一个个来
处理多线程问题时,多个线程访问同一个对象(并发),并且某些线程还想修改这个对象,这个时候我们就需要线程同步,线程同步就是一种机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。