目录
多线程编程
多线程编程是为了满足程序员编写高效率的程序来达到充分利用 CPU 的目的。
进程与线程
进程:操作系统管理的基本单元。进程包括由操作系统分配的内存空间,包含一个或多个线程。一个进程中可以并发多个线程,每条线程并行执行不同的任务。进程运行直到所有的非守护线程都结束运行后才能结束。
线程:进程中一个单一顺序的控制流,并且一个线程不能独立的存在,它必须是进程的一部分。
线程创建
Java提供了三种创建线程的方法:
- 继承
Thread
类 - 实现
Runnable
接口 - 实现
Callable
接口
继承Thread类
自定义线程类继承Thread
类,重写run
()方法编写线程执行体,创建线程对象,调用start
()方法启动线程。
//总结:注意线程开启不一定立即执行而是由cpu调度执行
public class TestThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("TestThread " + i);
}
}
public static void main(String[] args) {
//main线程
TestThread testThread = new TestThread();
testThread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("mainThread " + i);
}
}
}
习题:实现多线程下载网络图片
<!--commons-io-->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>
//实现多线程下载图片
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("https://img-blog.csdnimg.cn/20200222094548742.png?type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ2ODM5MA==,size_16,color_FFFFFF,t_70","1.png");
TestThread2 t2=new TestThread2("https://img-blog.csdnimg.cn/20200222094642116.png?type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ2ODM5MA==,size_16,color_FFFFFF,t_70","2.png");
TestThread2 t3=new TestThread2("https://img-blog.csdnimg.cn/20200222100207999.png?type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ2ODM5MA==,size_16,color_FFFFFF,t_70","3.png");
t1.start();
t2.start();
t3.start();
}
//下载器
public 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方法执行失败!");
}
}
}
}
实现Runnable接口
public class TestThread3 implements Runnable{
//线程体
@Override
public void run() {
for (int i=0 ;i<20;i++){
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//main线程,主线程
TestThread3 testThread = new TestThread3();
new Thread(testThread).start();
for (int i=0 ;i<20;i++){
System.out.println("主线程---"+i);
}
}
}
实现Runnable
接口具有多线程能力,启动线程:Thread对象.start(传入目标)。这样使用相对于继承Thread类避免OOP单继承局限性,灵活方便一个对象被多个线程使用。
初识并发问题
//多个线程同时操作同一个对象
//买火车票的例子
//发现问题:多个线程操作同一个资源的情况下,线程不安全了,数据紊乱了,比如:出现两个人抢到同一张票
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 testThread4=new TestThread4();
new Thread(testThread4,"小明").start();
new Thread(testThread4,"老师").start();
new Thread(testThread4,"黄牛党").start();
}
}
龟兔赛跑案例
//模拟龟兔赛跑
public class Race implements Runnable {
//胜利者
private static String winner;
@Override
public void run() {
for (int i=0;i<=100;i++){
//模拟兔子休息
if(Thread.currentThread().getName().equals("兔子") && i%10==0)
{
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
if (gameOver(i)){
break;
}
System.out.println(Thread.currentThread().getName()+"==>跑了"+i+"米");
}
}
//判断是否完成比赛
private boolean gameOver(int step){
//判断是否有胜利者
if (winner!=null){
return true;
}{
if (step==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();
}
}
实现Callable
接口
实现Callbale
接口,可以获取需要的返回值;重写call方法需要抛出异常。
- 创建目标对象
- 创建执行服务
- 提交执行
- 获取结果
- 关闭服务
//线程创建方式三
public class TestCallable implements Callable<Boolean> {
//网络文件地址
private String url;
//文件名
private String name;
public TestCallable(String url, String name) {
this.url = url;
this.name = name;
}
@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) {
TestCallable t1=new TestCallable("https://img-blog.csdnimg.cn/20200222094548742.png?type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ2ODM5MA==,size_16,color_FFFFFF,t_70","1.png");
TestCallable t2=new TestCallable("https://img-blog.csdnimg.cn/20200222094642116.png?type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ2ODM5MA==,size_16,color_FFFFFF,t_70","2.png");
TestCallable t3=new TestCallable("https://img-blog.csdnimg.cn/20200222100207999.png?type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ2ODM5MA==,size_16,color_FFFFFF,t_70","3.png");
//创建执行器服务:线程池,3条线程
ExecutorService service= Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> r1 = service.submit(t1);
Future<Boolean> r2 = service.submit(t2);
Future<Boolean> r3 = service.submit(t3);
//获取结果
try {
Boolean rs1 = r1.get();
Boolean rs2 = r2.get();
Boolean rs3 = r3.get();
System.out.println(rs1);
System.out.println(rs2);
System.out.println(rs3);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//关闭服务
service.shutdown();
}
//下载器
public 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方法执行失败!");
}
}
}
}
静态代理模式
//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处
//代理对象可以做很多真实对象做不了的事
//真是对象专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
new WeddingCompany(new You()).happyMarry();
//线程的底部实现原理:静态代理
//Thread代理对象 ()-> System.out.println("哈哈") lamdba表达式真实对象
new Thread(()-> System.out.println("哈哈")).start();
}
}
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("结婚之前,布置现场");
}
}
线程状态
源码:
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
生命周期
- 新建状态:使用
new
关键字和Thread
类或其子类建立一个线程对象后,该线程对象就处于新建状态。它保持这个状态直到程序
start
() 这个线程。 - 就绪状态:当线程对象调用了
start
()方法之后,该线程就进入就绪状态。就绪状态的线程处于就绪队列中,要等待JVM
里线程调度器的调度。 - 运行状态:如果就绪状态的线程获取
CPU
资源,就可以执行run
(),此时线程便处于运行状态。处于运行状态的线程最为复杂,它可以变为阻塞状态、就绪状态和死亡状态。 - 阻塞状态:如果一个线程执行了
sleep
(睡眠)、suspend
(挂起)等方法,失去所占用资源之后,该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。阻塞状态可以分为三种:等待阻塞(运行状态中的线程执行
wait() 方法,使线程进入到等待阻塞状态)、同步阻塞(线程在获取 synchronized
同步锁失败(因为同步锁被其他线程占用))、其他阻塞(通过调用线程的 sleep() 或 join() 发出了 I/O
请求时,线程就会进入到阻塞状态。当sleep() 状态超时,join() 等待线程终止或超时,或者 I/O
处理完毕,线程重新转入就绪状态) - 死亡状态:一个运行状态的线程完成任务或者其他终止条件发生时,该线程就切换到终止状态。线程中断或者结束,一旦进入死亡状态就不能再次启动。
执行原理![请添加图片描述](https://i-blog.csdnimg.cn/blog_migrate/505af24d28bd3d5e510b1d2187b91089.png)
https://blog.csdn.net/JustinQin/article/details/120453678