多线程
Thread
继承thread类
Thread类用于操作线程,是所以涉及到线程操作(如并发)的基础。
线程start启动线程与直接调用的区别
start方法的执行是CPU进行安排调度,并且每次执行的结果都不一样,有可能有快有慢,但是它们是同时进行,多线程
总结:线程开启程序不一定立即执行,是由CPU进行调度执行
run方法
我们先看一下直接调用run方法
//创建线程方式一:继承thread类,重写run()方法,调用start启动线程
public class TestThread extends Thread{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我正在看我的代码---" + i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
TestThread testThread = new TestThread();
//直接调用run方法执行时
testThread.run();
//调用Start开启线程时
// testThread.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程---" + i);
}
}
}
我们可以发现,这样的情况下,程序会先执行run方法后在去执行主线程程序
看下效果图:
start方法
我们再来看一下使用start方法进行启动线程时是什么效果
//创建线程方式一:继承thread类,重写run()方法,调用start启动线程
public class TestThread extends Thread{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我正在看我的代码---" + i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
TestThread testThread = new TestThread();
//直接调用run方法执行时
// testThread.run();
//调用Start开启线程时
testThread.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程---" + i);
}
}
}
可以看到这时程序方法会进行交替运行,这是由于线程不一定执行,是CPU来进行调度
看下效果图:
线程方法执行原理:
!图片来源于秦疆老师狂神说视频截取,若有冒犯联系删除~
线程启动理解练习
下面这个是进行了一个网图的下载,用来理解start线程时的理解
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习进行时,实现多线程同时下载图片
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 t1 = new TestThread2( "http://www.jiamin628.cn/skin/images/nybanner.jpg","n1.jpg");
TestThread2 t2 = new TestThread2( "http://www.jiamin628.cn/skin/images/logo.png","n2.jpg");
TestThread2 t3 = new TestThread2( "\thttp://www.jiamin628.cn/uploads/allimg/220103/1-2201031410090-L.jpg","n3.jpg");
t1.start();
t2.start();
t3.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方法出现故障");
}
}
}
来看下效果图:
在我们理想的线程中,图片的下载顺序应该是123,但是因为start的线程启动是通过CPU的调度进行,所以各种因素会导致下载的顺序不相同,并且每一次的下载顺序都不一样。
就是它的调动有可能会受到文件大小的因素影响,或者是其他的影响,但是线程开启程序不一定立即执行,是由CPU进行调度执行
!
!程序里提及的网站以及下载出来的图片来自www.jiamin628.cn提供!!
实现Runnable接口
- 定义MyRunnable类实现Runnable接口
- 实现run()方法,编写线程执行体
- 创建线程对象,调用start()方法进行启动线程
public class TestThread3 implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我正在看我的代码---" + i);
}
}
public static void main(String[] args) {
//创建runnable实现对象
TestThread3 testThread3 = new TestThread3();
//调用Start开启线程时
new Thread(testThread3).start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程---" + i);
}
}
}
和普通调用run方法的效果差不多,但是推荐使用runnable接口
=========================================================================================================
并发问题
但是 会有问题:当多个线程操作同一个资源的情况下,线程不安全,数据紊乱
例如以下代码:
//多个线程同时操作同一个对象
//买火车票的例子
public class TestThread4 implements Runnable{
//票数
private int ticketNums = 10;
@Override
public void run() {
while(true){
if(ticketNums <= 0){
break;
}
//模拟延时
try {
Thread.sleep(300);
}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();
}
}
演示结果:
callable
callable的好处:
- 可以定义返回值
- 可以跑出异常
静态代理模式
真实对象和代理对象都可以实现同一件事请,接入同一个接口
并且代理对象可以完成真实对象没能完成的事情
========================================================================
Lambda
作用:
- 避免匿名内部类定义过多
- 可以让你的代码看起来更加简结
- 去掉一堆没有意义的代码,只留下核心的逻辑
package TestLambda;
//推导Lambda公式
public class TestLambda1 {
//3.静态内部类
static class Like2 implements Ilike{
@Override
public void lambda() {
System.out.println("I Like Lambda2!!!");
}
}
public static void main(String[] args) {
Ilike ilike = new Like();
ilike.lambda();
ilike = new Like2();
ilike.lambda();
//4.局部内部类
class Like3 implements Ilike{
@Override
public void lambda() {
System.out.println("I Like Lambda3!!!");
}
}
ilike = new Like3();
ilike.lambda();
//5.匿名内部类,没有类的名称,必须借助接口或者父类
ilike = new Ilike() {
@Override
public void lambda() {
System.out.println("i like Lambda4");
}
};
ilike.lambda();
//6.用Lambda简化
ilike = ()->{
System.out.println("i like Lambda5");
};
ilike.lambda();
}
}
//1.定义接口
interface Ilike{
void lambda();
}
//2.实现类
class Like implements Ilike{
@Override
public void lambda() {
System.out.println("I Like Lambda!!!");
}
}
Lambda简化一行代码进化演示:
package TestLambda;
public class TestLambda2 {
public static void main(String[] args) {
//1.Lambda形式简化
iLove love = (int a)->{
System.out.println("I LOVE YOU-->" + a);
};
//1.简化参数类型
love = (a)->{
System.out.println("I LOVE YOU-->" + a);
};
//2.简化括号
love = a->{
System.out.println("I LOVE YOU-->" + a);
};
//3.简化花括号
love = a->System.out.println("I LOVE YOU-->" + a);
love.love(5201314);
}
}
interface iLove{
void love(int a);
}
总结:Lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就要用代码块包裹
前提是接口为函数型接口
多个参数的情况下也可以去掉参数类型,要去掉就都去掉,必须加上括号
======================================================================================================
线程的状态
创建状态:new一个新的对象
启动状态(准备就绪):利用start启动程序
运行状态:程序启动运行中,中途有可能因为进入阻塞状态而回到启动状态
停止状态:让某一线程进入停止状态
停止状态
- 建议线程正常停止,使用次数停止,不建议进入死循环
- 建议使用标志位—》设置一个标志位
- 不要使用stop或者destory等过时或者jdk不建议使用的方法进行停止
代码演示:
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 = flag;
}
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("该线程已成功停止");
}
}
}
}
========================================
睡眠状态sleep
- 指定当前线程阻塞的毫秒数
- 存在异常InterruptExceptio
- 时间达到后线程进入就绪状态
- 可以模拟网络延迟或者倒数等
- 每一个对象都有一个锁,sleep状态不会释放锁
代码演示:
模拟网络延时:
package state;
import TestThreadDemo.TestThread4;
//模拟网络延时
public class TestSleep implements Runnable{
private int ticketNums = 10;
@Override
public void run() {
while(true){
if(ticketNums <= 0){
break;
}
//模拟延时
try {
Thread.sleep(300);
}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();
}
}
模拟倒计时运行:
//模拟倒计时
public class TestSleep2 {
public static void main(String[] args) throws InterruptedException {
tenDown();
}
public static void tenDown() throws InterruptedException{
int time = 10;
while (true){
Thread.sleep(1000);
System.out.println(time--);
if(time<0){
break;
}
}
}
}
模拟系统当前的时间并且进行倒计时:
import java.util.Date;
import java.text.SimpleDateFormat;
//模拟倒计时
public class TestSleep2 {
public static void main(String[] args) throws InterruptedException {
//打印当前系统的时间
Date startTime = new Date(System.currentTimeMillis());
while (true){
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis());//更新当前时间
}
}
public static void tenDown() throws InterruptedException{
int time = 10;
while (true){
Thread.sleep(1000);
System.out.println(time--);
if(time<0){
break;
}
}
}
}
========
礼让状态:
让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{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+ "线程开始执行" );
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+ "线程停止执行" );
}
}
运行结果:
虽然有礼让线程但不一定会成功
在没有礼让线程的时候程序运行的结果应该是:
a线程开始执行
a线程停止执行
b线程开始执行
b线程停止执行
而在有礼让线程的情况下的运行结果就会像图二一样,会在b线程开始后才停止运行
!!!注意,这里不一定会礼让成功,一切看CPU心情
=========================================
强制执行线程-Join
- Join合并线程,待线程执行完成后,再执行其他线程,其他线程会造成一个阻塞
- 我们可以把他想象成插队
代码区:
//测试join插队
public class TestJoin implements Runnable{
public static void main(String[] args) throws InterruptedException {
//启动线程
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
//主线程
for (int i = 0; i < 500; i++) {
System.out.println("main" + i);
if(i == 400){
thread.join();//插队
}
}
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程VIP来了!");
}
}
}
==============================================
观察线程的状态
代码:
package state;
public class TestState {
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);//New
//观察启动后
thread.start();
state = thread.getState();
System.out.println(state); //Run
while (state != Thread.State.TERMINATED){
//只要线程不终止,就一直输出状态
Thread.sleep(1000);
state = thread.getState();//更新线程状态
System.out.println(state);//输出状态
}
}
}
!!!死亡后的状态不可以直接包内重新启动
=========================================================================
线程的优先级
大多数时候是设置到的优先级高的会先执行程序,但是不是一定是高的就一定先跑,一样需要配合CPU的调动
优先级只有1-10个等级,超过这个范围会直接报错
优先级低只是代表获得CPU调度的概率低。并不是优先级低就不会被调用了,主要还是要看CPU的调度!
优先级建议设置在start()方法前
=============================
守护状态(daemon)
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 比如说,后台记录操作日志,监控内存,垃圾回收等的。。。
当线程启动时,守护线程会跟随启动,但守护线程是一个一直循环线程,而当用户线程结束时,守护线程会随之结束
以下为模拟上帝代码:
package 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{
@Override
public void run() {
while (true){
System.out.println("放心,上帝一直守护着你长大!");
}
}
}
//你
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 365000; i++) {
System.out.println("真好!上帝一直守护着你的生活!你一生都开心地活着");
}
}
}
====================================================================
线程同步机制
不安全案例
人在买票的时候通常会很自觉德排队买票,但是程序只会执行,如果让程序去买票,并且没有限制,那么在买票时就会出现重复买票的现象或者说出现负数票,0票的状态,这样的操作并不安全
package state;
//不安全的买票例子
//线程不安全,有负数
public class UnsafeBuyticket {
public static void main(String[] args) {
Buyticket station = new Buyticket();
new Thread(station,"小明同学").start();
new Thread(station,"二炮").start();
new Thread(station,"朗哥 ").start();
}
}
class Buyticket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true;//外部停止方式
@Override
public void run() {
//买票进行
while (flag){
try {
buy();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if(ticketNums <= 0){
return;
}
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "买到了" + ticketNums--);
}
//买票
}
安全同步方法
线程协作
简述:生产消费者模式
控制进行停止,多线程某线程的执行或者停止
线程池
//买票进行
while (flag){
try {
buy();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if(ticketNums <= 0){
return;
}
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "买到了" + ticketNums--);
}
//买票
}
#### 安全同步方
## 线程协作
简述:生产消费者模式
**控制进行停止,多线程某线程的执行或者停止**
## 线程池