多线程自学笔记（总结自狂神说视频）

一、线程介绍

1）进程的概念

进程是执行程序的一次执行过程，他是一个动态的概念。是系统资源分配的单位。

2）线程的概念

一个进程中包含若干个线程，线程是cpu调度和执行的单位。

核心概念

❶线程就是独立路径
❷在程序运行时，即使没有自己创建线程，后台也会有多个线程 ，如主线程，gc线程；
❸main()称之为主线程，为系统的入口
❹在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
❺对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
❻线程会带来额外的开销，如cpu调度时间，并发控制开销
❼每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

二、线程实现（重点）

1）继承Thread类（重点）

///创建线程方式一：继承Tread类，重写run()方法，调用start开启线程
public class TestTread1 extends Thread{
	//run方法线程体
	for(int i = 0;i < 200;i++){
		System.out.println("我在看代码---"+i);
	}
}
public static void main(String[] args){
	//创建一个线程对象
	TestThread1 testThread1 = new TestThread1();
	//调用start()方法开启线程
	testThread1.start();
	//mian线程，主线程
	for(int i = 0;i < 2000;i++){
		System.out.println("我在学习多线程---"+i);
	}
} 

结果如下：

两个线程交替执行，重启后结果也会不一样
总结：注意，线程的开启不一定立即执行，有cpu调度执行

小练习,下载网络图片

import org.apache.commons.io.FileUtils;//需要自己下载jar包
import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习Thread，实现多线程同步下载
public class TestThread2{
	private String url;
	private String name;

	public TestThread2(String url,String name){
		this.name=name;
		this.url=url;
	}
	
	@Override
	public void run(){
	WebDownloader webDownloader = new WebDownloader();
	webDownloader.downloader(url,name);
	}
	public static void main(String[] args){
		TestThread2 t1 = new TestThread2("你要天的网络图片地址","设置的图片名称");
		TestThread2 t2 = new TestThread2("你要天的网络图片地址","设置的图片名称");
		TestThread2 t3 = new TestThread2("你要天的网络图片地址","设置的图片名称");
		
		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方法出现问题");
	}
}

2）实现Runnable接口（重点）

//创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入Runnable接口实现类，调用start方法。
public class TestThread3 implements Runnable{
	@Override
	public void run(){
		//run方法线程体
		for(int i = 0;i<200;i++){
		System.out.println("我在看代码---"+i);
		}
	}
	public static void main(String[] args){
		//创建Ruunable接口实现类对象
		TestThread3 testThread3 = new TestThread3();
		//创建线程对象，通过线程对象来开启我们的线程，代理
		Thread thread = new Thread(testThread3);
		thread.start();
		for(int i=0;i<1000;i++){
			System.out.println("我在学习多线程--"+i);
		}
	}	
}

小结

继承Thread类
1.子类继承Thread类具备多线程能力
2.启动线程：子类对象.start()
3.不建议使用：避免OOP单继承局限性
实现Runnable
1.实现接口Runnable具有多线程能力
2.启动线程：传入对象+Thread对象.start()
3.推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

练习，初识并发问题

//多个线程操作同一个对象
//买火车票的例子

//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
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();
	}
}

结果：

案例–模拟龟兔赛跑

//模拟龟兔赛跑
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(200);
			}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();
	}
}

结果：

3）实现Callable接口（了解即可）

1.实现Callable接口，需要返回值类型
2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务：ExecutorService ser =Executors.newFixedPool(1);
5.提交执行：Future < Boolean> result1 = ser.submit(1)
6.获取结果：boolean r1 = result1.get()
7.关闭服务：ser.shutdownNow(1);

//线程创建三：实现Callable接口
/*
Callable的好处
1.可以自定义返回值
2.可以抛出异常
*/
public class TestCallable implements Callable<Boolean>{
	private String url;
	private String name;

	public TestThread2(String url,String name){
		this.name=name;
		this.url=url;
	}
	
	@Override
	public Boolean call(){
	WebDownloader webDownloader = new WebDownloader();
	webDownloader.downloader(url,name);
	return true;
	}
	public static void main(String[] args){
		TestCallable t1 = new TestThread2("你要天的网络图片地址","设置的图片名称");
		TestCallable t2 = new TestThread2("你要天的网络图片地址","设置的图片名称");
		TestCallable  t3 = new TestThread2("你要天的网络图片地址","设置的图片名称");
		
		//创建执行服务
		ExecutorService ser =Executors.newFixedPool(3);
		//提交执行
		Future <Boolean> r1 = ser.submit(t1);
		Future <Boolean> r2 = ser.submit(t2);
		Future <Boolean> r3 = ser.submit(t3);
		//获取结果
		boolean r1 = result1.get();
		boolean r2 = result2.get();
		boolean r3 = result3.get();
		System.out.println(r1);
		System.out.println(r2);
		System.out.println(r3);
		//关闭服务
		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方法出现问题");
	}
}

线程状态

线程五大状态

**本图截屏自B站狂神说视屏教程

线程方法

**本图截屏自B站狂神说视屏教程

线程的停止

package com.kuang.thread;
/**
 * 测试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("线程已停止");
            }
        }
    }

}

线程的休眠

◆sleep（时间）指定当前线程阻塞的毫秒数；
◆sleep存在异常InterruptedException；
◆sleep时间达到后线程进入就绪状态
◆sleep可以模拟网络延时，倒计时等
◆每个对象都有一个锁，sleep不会释放锁

例子：

package com.kuang.thread;
/**
 * 测试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("线程已停止");
            }
        }
    }

}

运行结果：

线程同步

线程通信问题

高级主题