文章目录
一、创建线程
1、继承Thread实现创建线程
自定义线程类继承Thread类
重写run()方法,编写线程执行体
创建线程对象,调用start()方法启动线程
//创建线程方式一:继承Thread类,重写run方法,调用start开启线程
public class TestThread1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//main主线程
//创建一个线程对象
TestThread1 testThread1 = new TestThread1();
//调用start()方法开启线程
testThread1.start();
for (int i = 0; i < 200; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
2、下载图片案例
首先需要在百度搜索commons-io的jar包,并导入lib下
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线线程同步下载图片
public class ImageDownload extends Thread{
private String url;
private String name;
public ImageDownload(String url, String name){
this.url = url; //网络图片地址
this.name = name; //保存的文件名称
}
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
try {
webDownloader.downloader(url,name);
System.out.println("下载的文件名为:"+name);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ImageDownload imageDownload1 = new ImageDownload("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fwww.tutuzx.com%2Fd%2Ffile%2Ftitlepic%2F20210104%2F5aexbhmdkgq.jpg&refer=http%3A%2F%2Fwww.tutuzx.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1634471819&t=d3c1dac65f22edf5ca2d531721ac9e82","1.jpg");
ImageDownload imageDownload2 = new ImageDownload("https://pics2.baidu.com/feed/43a7d933c895d14321b1075bdbc863055baf0747.jpeg?token=aa7eedf81a790c1dfe2871a3a076bafd&s=1C02137C4440D7475EA9F5EC0300302D","2.jpg");
ImageDownload imageDownload3 = new ImageDownload("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fi-1-lanrentuku.qqxzb-img.com%2F2020%2F12%2F23%2Fe64df5e8-95e1-4f9e-b47c-d6acb61c3ac5.jpg%3FimageView2%2F2%2Fw%2F1024%2F&refer=http%3A%2F%2Fi-1-lanrentuku.qqxzb-img.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1634471951&t=9a56af8617fe78b0160ded2921db070f","3.jpg");
imageDownload1.start();
imageDownload2.start();
imageDownload3.start();
}
}
class WebDownloader{
public void downloader(String url,String name) throws IOException {
FileUtils.copyURLToFile(new URL(url),new File(name));
}
}
3、初识并发的问题
模拟车票购买,并发就是两个人会同时抢到同一张票
小白拿到了第10—张票
小明拿到了第9—张票
小黄拿到了第8—张票
小白拿到了第7—张票
小黄拿到了第7—张票
小明拿到了第7—张票
小明拿到了第6—张票
小黄拿到了第6—张票
小白拿到了第6—张票
小白拿到了第5—张票
小明拿到了第5—张票
小黄拿到了第5—张票
小明拿到了第4—张票
小黄拿到了第4—张票
小白拿到了第4—张票
小黄拿到了第3—张票
小白拿到了第1—张票
小明拿到了第2—张票
package com.geng.demo1;
//发现问题:多个线程同时操作一个资源,线程不安全,数据紊乱。
public class BuyTicket 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) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"小明").start();
new Thread(buyTicket,"小白").start();
new Thread(buyTicket,"小黄").start();
}
}
4、继承Thread创建多线程和实现Runnable创建多线程的区别
5、龟兔赛跑案例,巩固多线程
package com.geng.demo1;
public class Race implements Runnable{
private static String winner;
@Override
public void run() {
boolean flag;
for (int i = 1; i <= 100 ; i++) {
if(Thread.currentThread().getName().equals("兔子") && i % 10 == 0){
try {
Thread.sleep(1);
System.out.println("兔子睡觉了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
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();
}
}
6、实现Callable接口
实现Callable接口,需要返回值类型
重写call方法,需要抛出异常
创建目标对象
创建执行服务:
ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行:
Future<Boolean> result1 = ser,sumbit(t1);
获取结果:
boolean r1 = result1.get()
关闭服务:
ser.shutdownNow();
仿照图片下载实现Callable接口
import java.io.IOException;
import java.util.concurrent.*;
//线程创建方式三:实现callable接口
//优点:可以获取返回值和抛出异常
public class TestCallable implements Callable {
private String url;
private String name;
public TestCallable(String url, String name){
this.url = url;
this.name = name;
}
@Override
public Boolean call() {
WebDownloader webDownloader = new WebDownloader();
try {
webDownloader.downloader(url,name);
System.out.println("下载的文件名为:"+name);
} catch (IOException e) {
e.printStackTrace();
}
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestCallable t1 = new TestCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fwww.tutuzx.com%2Fd%2Ffile%2Ftitlepic%2F20210104%2F5aexbhmdkgq.jpg&refer=http%3A%2F%2Fwww.tutuzx.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1634471819&t=d3c1dac65f22edf5ca2d531721ac9e82","4.jpg");
TestCallable t2 = new TestCallable("https://pics2.baidu.com/feed/43a7d933c895d14321b1075bdbc863055baf0747.jpeg?token=aa7eedf81a790c1dfe2871a3a076bafd&s=1C02137C4440D7475EA9F5EC0300302D","5.jpg");
TestCallable t3 = new TestCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fi-1-lanrentuku.qqxzb-img.com%2F2020%2F12%2F23%2Fe64df5e8-95e1-4f9e-b47c-d6acb61c3ac5.jpg%3FimageView2%2F2%2Fw%2F1024%2F&refer=http%3A%2F%2Fi-1-lanrentuku.qqxzb-img.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1634471951&t=9a56af8617fe78b0160ded2921db070f","6.jpg");
//创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行
Future r1 = ser.submit(t1);
Future r2 = ser.submit(t2);
Future r3 = ser.submit(t3);
//获取结果
Boolean rs1 = (Boolean) r1.get();
Boolean rs2 = (Boolean) r2.get();
Boolean rs3 = (Boolean) r3.get();
//关闭服务
ser.shutdownNow();
}
}
7、静态代理模式
利用静态代理模式思想,来解释实现Runnable接口的原理。
//静态代理模式总结:
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处:代理对象可以做很多真实对象做不了的事情
//真实对象可以专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
WeddingCompany a = new WeddingCompany(new You());
a.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();
}
public void before(){
System.out.println("结婚之前布置现场");
}
public void after(){
System.out.println("结婚之后收尾款");
}
}
8、Lamda表达式
public class TestLambda {
//静态内部类
static class Like2 implements ILike{
@Override
public void Lambda() {
System.out.println("I like lambda2");
}
}
public static void main(String[] args) {
Like2 like = new Like2();
like.Lambda();
Like like1 = new Like();
like1.Lambda();
//局部内部类
class Like3 implements ILike{
@Override
public void Lambda() {
System.out.println("I like lambda3");
}
}
Like3 like3 = new Like3();
like3.Lambda();
//匿名内部类,没有类的名称,必须借助接口或者父类
ILike like4 = new ILike() {
@Override
public void Lambda() {
System.out.println("I like lambda4");
}
};
like4.Lambda();
//用lambda简化
ILike like5 = ()->{
System.out.println("I like lambda5");
};
like5.Lambda();
//lambda简化,去大括号
like5 = () -> System.out.println("shuchu");
}
}
//总结:lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块包裹
//前提是接口为函数式接口
//多个参数也可以去掉参数类型,要去就都去掉,必须加上括号;
interface ILike{
void Lambda();
}
class Like implements ILike{
@Override
public void Lambda() {
System.out.println("I like lambda");
}
}
二、线程状态
创建状态
就绪状态
运行状态
阻塞状态
死亡状态
1、线程停止
//测试stop
//1、线程正常停止--->利用次数,不建议死循环
//2、建议使用标志位--->设置一个标志位
//3、不要使用stop或destroy等过时或者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 = 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("线程停止了");
}
}
}
}
2、线程休眠
import java.text.SimpleDateFormat;
import java.util.Date;
//模拟网络延时:放大问题的发生性,见网络购票
//模拟倒计时
public class TestSleep {
public static void main(String[] args) throws InterruptedException {
//打印当前系统时间
Date date = new Date(System.currentTimeMillis()); //获取当前系统时间
while (true){
System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
Thread.sleep(1000);
date = new Date(System.currentTimeMillis()); //更新系统时间
}
}
3、线程礼让—yield
//测试礼让线程
//礼让不一定成功,看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线程开始执行
b线程开始执行
b线程停止执行
a线程停止执行
4、线程强制执行——JOIN
//测试JOIN方法,想插队
public class TestJoin implements Runnable{
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 1000; 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 < 1000; i++) {
if (i == 200){
thread.join(); //执行插队
}
System.out.println("main"+i);
}
}
}
5、观测线程状态
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);
//观察启动后
thread.start();
state = thread.getState();
System.out.println(state);
//只要线程不终止,就一直输出状态
while (state != Thread.State.TERMINATED){
Thread.sleep(100);
state = thread.getState(); //更新线程
System.out.println(state);
}
}
}
6、线程的优先级
//测试线程的优先级
public class TestPriority {
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);
//先设置优先级,再启动
thread1.setPriority(1);
thread1.start();
thread2.setPriority(1);
thread2.start();
thread3.setPriority(1);
thread3.start();
thread4.setPriority(Thread.MAX_PRIORITY);
thread4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
}
}
7、守护线程
//测试守护线程
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You1 you1 = new You1();
Thread thread = new Thread(god);
thread.setDaemon(true); //默认是false,表示是用户线程,正常的线程都是用户线程
thread.start(); //启动守护线程
new Thread(you1).start(); //启动用户线程
}
}
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝护佑你!");
}
}
}
class You1 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 356; i++) {
System.out.println("你一生活得都开心");
}
System.out.println("===========goodbye world!==========");
}
}
8、同步方法及代码块
//测试守护线程
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You1 you1 = new You1();
Thread thread = new Thread(god);
thread.setDaemon(true); //默认是false,表示是用户线程,正常的线程都是用户线程
thread.start(); //启动守护线程
new Thread(you1).start(); //启动用户线程
}
}
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝护佑你!");
}
}
}
class You1 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 356; i++) {
System.out.println("你一生活得都开心");
}
System.out.println("===========goodbye world!==========");
}
}
//发现问题:多个线程同时操作一个资源,线程不安全,数据紊乱。
class Tickets{
private int ticketNums = 10;
public int getTicketNums() {
return ticketNums;
}
public void setTicketNums(int ticketNums) {
this.ticketNums = ticketNums;
}
}
public class BuyTicket implements Runnable{
Tickets tickets = new Tickets(); //票数
int ticketNums = tickets.getTicketNums();
@Override
public void run() {
while (true){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (tickets){
//()中放的是需要操作的资源对象,synchronized默认是run方法
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) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"小明").start();
new Thread(buyTicket,"小白").start();
new Thread(buyTicket,"小黄").start();
}
}
已完结