线程简介
-
进程：
- 一段正在运行的程序
- 是程序执行过程中资源分配和管理的基本单位 (相对与操作系统而言)
- 进程拥有自己独立的地址空间，梅启动一个进程，系统就会分配地址空间
- 进程拥有若干（一个及以上）线程，各个线程之间共享程序的内存空间
-
线程：
- 一个程序运行中可以执行多个任务，任务称之为线程
- 线程是CPU调度和执行的基本单位
- 线程支持进程的执行
-
多线程：多条执行路径，主线程和子线程交替执行
1.有进程，为什么出现线程？
- 主要原因是进程有自己独立的地址空间，多并发请求时，为每一个请求创建一个进程，导致系统开销大，用户请求效率低
2.JVM对应的五个地址空间---->JVM本身就是一个进程
进程的空间为这五个部分（所有线程共享这五部分**，有几部分是线程独有的，即就是进程为线程在某些地方专门开辟一片地址空间，是一个线程本身所拥有的？独有的为两个栈和PC，相对与进程而言**）
-
虚拟机栈：java方法在线程执行的时候虚拟机栈创建一个栈帧（包含方法的上下文），方法隶属于线程
-
本地方法栈：为native方法服务
-
程序计数器：用来记录某个线程下次执行的指令位置
-
方法区：类信息、常量池、静态变量、编译后的代码
-
堆：new出来的对象
计算机早期是串行—》批处理（一批一批处理）----》进程（系统资源消耗大、但是安全）----》线程
3.多线程和多进程有哪些区别？
-
每个进程拥有自己独有的变量，线程共享数据
所以线程之间的通信相比于进程之间的通信更有效，更容易
-
线程相比于进程的创建/销毁 开销更小
-
进程是资源分配的基本单位，线程是CPU调度的基本单位
-
多进程程序更加健壮（安全），多线程程序只要有一个线程出错，对其共享资源的其他其他资源也会产生影响
-
如果追求速度 ，或者频繁创建和销毁选择线程，
-
如果追求系统更加稳定，选择进程
-
线程是轻量级的进程
线程实现（重点）
1、继承Thread类
/**
* 创建线程方式一：继承Thread类，重写run方法，调用start开启线程
*
*/
public class TestThread extends Thread{
@Override
public void run() {
//run方法线程体
for(int i= 0 ;i<5;i++){
System.out.println("我在看代码--------"+i);
}
}
public static void main(String[] args) {
//main线程 ， 主线程
//创建一个线程对象
TestThread testThread= new TestThread();
//启动线程
testThread.start();
for(int i= 0 ;i<5;i++){
System.out.println("我在看学习--------"+i);
}
}
}
课堂练习：使用commons io jar包 使用多线程下载图片
- 在网上下载工具包commons io jar包
- 创建一个lib包 将这个工具包ctrl+c ctrl+v 导入后不能直接用，右击有个Add as LIbrary添加到库中
3.
-
实现多线程同步下载图片
-
首先构造一个下载器
import org.apache.commons.io.FileUtils; class WebDoenLoader{ //下载器 public void downLoader(String url,String name){ //下载方法 //使用文件工具类，下载图片 try{ FileUtils.copyURLToFile(new URL(url),new File(name)); }catch(IOException e){ e.printStrackTrace(); System.out.print("IO异常，dowmloader出现问题")； } } -
使用多线程实现并发下载
- 使类继承Thread类
- 确定属性
- url、name
- 构造方法
- 重写run方法
- 线程执行体
- 需要一个下载器
- 调用下载器的下载方法
- 打印下载的文件名
- 在主函数即主线程中创建三个线程对象
- 传入图片的url
- 在网上找到图片----》 右击 -----》检查----》看源码中有src=”地址“，即可找到地址，双击后复制地址
//练习Thread ，实现多线程下载图片
public class TestThread2 extends TestThread {
private String url;
private String name;
public TestThread2(String url,String name){ //构造器
this.name=name;
this.url=url;
}
//下载图片的执行体
@Override
4
public static void main(String[] args) {
TestThread2 t1 = new TestThread2("https://i04piccdn.sogoucdn.com/77e41307bd9ad15c","1.jpg");
TestThread2 t2 = new TestThread2("https://img04.sogoucdn.com/app/a/100520024/115203334039cdd730bfa5d4685e8143","2.jpg");
TestThread2 t3 = new TestThread2("https://img02.sogoucdn.com/app/a/100520024/70c311ef1684a90c77673efd2ce35edf","3.jpg");
t1.start(); //启动线程
t2.start();
t3.start();
}
}
下载成功：
2、实现Runnable接口
//创建RUnnable接口的实现类对象
TestThread3 testThread3 = new TestThread3();
//创建线程对象 ，通过线程对象来开启我们的线程，代理
//第一种
Thread thread = new Thread( testThread3 ); // 需要将我们RUnnable接口的实现类对象当作参数传入
thread.start(); //只有Thread类对象才能有start方法
//第二种简写
new Thread(testThread3).start(); // 简写
-
实现接口Runnable具有多线程能力
-
启动线程：需要借助Thread类对象来启动 （传入目标对象即实现Runable接口的类对象+Thread 对像.start()）
-
推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用eg:package thread.kuangThread.TestThread4;
一个对象，多个代理 ------->RunnableTest 龟兔赛跑
TestThread4 testThread4 = new TestThread4(); new Thread(testThread4,"小明").start(); new Thread(testThread4,"小花").start(); new Thread(testThread4,"小李").start();
3、实现Callable接口(了解）
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛异常
- 创建目标对象
- 创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行 Future result1 = ser .submit(1);
- 获取结果 boolean r1 =result.get();
- 关闭服务 ser.shutdownNow();
实现Callable的好处
- 有返回值
- 可以抛异常
线程状态生命周期及常用方法解析
线程可以处于一下状态之一
- NEW：尚未启动的线程处于此状态
- new关键字创建一个对象，它并不是处于一个执行的状态，因为还没有start启动线程
- RUNNABLE：在java虚拟机中执行的线程处于此状态
- 线程调用start方法，才是在JVM中真正创建了一个线程，线程一旦启动，并不会立即执行，该状态的所有线程位于就绪线程池中，等待操作系统的资源，如：处理器，获得CPU的使用权
- BLOCKED：被阻塞等待监视器锁定的线程处于此状态
- 等待一个监视器锁进入同步代码块或者同步方法，代码块/方法 某一时刻只能有一个线程执行，其它线程只能等待
- WAITING：正在等待另一个线程执行特定的动作的线程处于此状态
- Object.wait()/Thread.join()/LockSupport.park() 方法都会使得线程阻塞从Runnable状态到Waiting状态
- TIMED_WAITING：正在等待另一个线程执行动作到达指定等待时间的线程处于此状态
- 调用增加超时参数的这些方法Object.wait(long mills) / Thread.join(long mills) / LockSupport.parkUntil() 都会使得线程阻塞从Runnable状态到Timed_Waiting状态
- TERMINATED :已退出的线程处于此状态
- 是一个线程的最终状态，线程进入terminated状态，意味着该线程的生命周期都结束了
- 下面这些情况都回使得线程进入terminated状态
- 线程执行正常结束
- 线程运行出现意外错误
- JVM crash
线程六状态的转换图
观测线程的状态
public class TestState {
public static void main(String[] args) {
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); //RUNNABLE
while (state!=Thread.State.TERMINATED) { //只要线程不终止，就一直输出状态
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
state=thread.getState(); //更新线程状态
System.out.println(state); //输出状态
}
}
}
线程中常用方法的解析
-
start(）
启动一个线程，将线程添加到一个线程组中，线程状态会从New状态转换到Runnable状态，然后获取CPU后进入Running状态执行run（）
-
sleep（）
- 使用sleep方法模拟网络延时，：可以放大问题的发生性
- 模拟倒计时
sleep是一个静态方法，其中存在两个重载函数
public static void sleep(long millis)
public static void sleep(long millis,int nanos)
使得线程进入睡眠状态，暂停执行，sleep不会放弃monitor lock的使用权
JDK1.5之后引入了一个枚举类TimeUnit,其对sleep方法做了封装，直接使用从而省去了时间换算的步骤，比如线程随眠3h27min8s88millis
new Thread(()->{ try { TimeUnit.HOURS.sleep(3); TimeUnit.MINUTES.sleep(27); TimeUnit.SECONDS.sleep(8); TimeUnit.MILLISECONDS.sleep(88); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); -
yield()
yield 表示提醒CPU调度器，愿意放弃当前的cpu资源(时间片)，属于启发式方法，如果CPU不紧张的时候，就会忽略这种提醒
面试题: yield()与sleep()的区别
-
jdk1.5之前，yield调用了sleep方法
-
sleep使得当前线程暂停执行，不会占用cpu资源
yield只是对cpu的一个提示
-
sleep会导致线程的短暂阻塞，yield可能会使得线程从Running状态转变为Runnable状态
-
sleep会捕获到中断异常，yield不会捕获到中断异常
-
join()
含义：在线程B中join某个线程A，会使得线程B等待，直到线程A结束生命周期，或者是达到给定的时间，在这期间B会进入等待状态
练习：A、B、C三个线程，使得三线程顺序打印出1~10
public class TestDemo6 extends Thread{ private Thread thread;D private String name; public TestDome6(Thread thread, String name) { this.thread = thread; this.name = name; } @Override public void run() { if(thread!=null){ try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } } for (int i=1;i<11;i++){ System.out.println(name+" : : "+i); } } public static void main(String[] args) { //A、B、C三个线程，使得三线程顺序打印出1~10 Thread A = new TestDome6(null,"线程A"); Thread B = new TestDome6(A,"线程B"); Thread C = new TestDome6(B,"线程C"); A.start(); B.start(); C.start(); } } -
wait()
-
notify()
-
notifyAll()
线程通信的三个方法，属于Object里面的方法。即任何对象都可以调用
wait() 调用某个对象的wait()方法可以让这个线程阻塞（操作系统层面的），会释放当前对象的monitor lock
notify() / notifyAll() ：调用当前对象的notify()/notifyAll() 方法可以唤醒这个对象所在的线程
注意：使用这三个方法时，必须要让当前线程拥有当前对象的monitor lock
所有对象天生拥有一把锁，可以用 synchronized 方法获取该对象的锁，就可以调用wait/notify方法// 先理解，线程通信的时候会详细介绍
// 先理解，线程通信的时候会详细介绍
public class TestDemo5 {
public static void main(String[] args) {
String strs = new String("Test wait");
synchronized(strs){ //获取当前对象的锁
new Thread("A"){
@Override
public void run() {
//同步代码块
try {
strs.wait(); //阻塞，释放锁 ,之后被唤醒后，要重新抢锁，然后执行下面的语句
System.out.println("i eat apple");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}
synchronized (strs){
new Thread("B"){
@Override
public void run() {
strs.notify();//随机唤醒一个当前对象阻塞的线程
strs.notifyAll();//唤醒当前对象的所有阻塞的线程，去争抢一把锁
}
}.start();
}
}
}
线程中断方法：
每个Jaava线程都会有一个中断状态位，程序可以检测这个中断状态位判断线程是否执行结束
- a. interruput()
public void interruput() 由线程对象调用，将中断位置置为true
-
如下方法使得当前线程进入阻塞状态，调用interruput方法可以打断阻塞，但不是结束线程的生命周期，因此这种方法被成为可中断方法
- Object.wait() /wait (long)
- Thread.sleep(long) / TimUnit.XXX.sleep(long)
- Thread.join() / Thread.join(long)
-
interruput
- 如果一个线程被中断，则会设置中断状态位。如果当前线程没有执行可中断方法时，调用当前线程的interruput方法时，中断状态位会置为true。如果当前线程正在执行可中断方法(进入阻塞时)，再调用当前线程的interruput方法时，可中断方法反而会导致中断状态位不会置为true，而是将中断状态位清除至它原本的中断状态位。
-
b.isInterruputde ：判断当前线程的中断状态位是否位true
-
c . interruputed
- public static void interruputed () 静态方法
- 调用interruputed会清除中断状态位的标识
1、调用interruputed 擦除状态位
public class TestInterruput {
public static void main(String[] args) {
Thread thread= new Thread(()->{
});
thread.start();
thread.interrupt();
System.out.println(thread.isInterrupted());
thread.interrupted();
System.out.println(thread.isInterrupted());
}
}
2、执行可中断方法时，会将中断状态位清除掉
import java.util.concurrent.TimeUnit;
public class TestInterruput {
public static void main(String[] args) {
Thread thread= new Thread(()-> {
while (true) {
System.out.println("Test Interruput");
try {
TimeUnit.MILLISECONDS.sleep(2000);
} catch (InterruptedException e) {
System.out.println("执行可中断方法时的中断状态位为："+Thread.currentThread().isInterrupted());
}
}
});
thread.start(); //等待被CPU调度
thread.interrupt();
System.out.println("执行 interruput方法时的中断状态位为："+thread.isInterrupted());
}
}
线程的优先级
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度那个线程来执行,优先级只是提高线程被调用的几率
-
线程的优先级按照数字来表示，范围为1~10
- Therad.MIN_PRIORITY=1;
- Therad.MAX_PRIORITY=10;
- Therad.NORM_PRIORITY=5;
-
使用一下方式改变或获取优先级
- getPriority();
- setPriority( int XXX);
注意：先设置优先级，再启动
- 优先级只是提高线程被调用的几率，并不一定完全按照优先级调度
/*
测试线程的优先级
*/
public class TestPriority {
public static void main(String[] args) {
System.out.println("主线程默认优先级"+" --->"+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(7);
t2.start();
t3.setPriority(1);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY); //等价于 10
t4.start();
t5.setPriority(3);
t5.start();
t6.setPriority(8);
t6.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" --->"+Thread.currentThread().getPriority());
}
}
可以看出并不是优先级高的先执行，优先级低只是意味着CPU调度的概率低，并不是优先级低就不会被调用，这一切看CPU的调度
守护(daemon)线程
- 线程分为用户线程和守护线程
- 虚拟机必须保证所有用户线程都执行完毕
- 虚拟机不用等待守护线程执行完毕 如：后台记录操控日志、垃圾回收(gc)等守护线程
-
什么是守护线程
守护线程是一类比较特殊的线程，一般用户处理后台的工作，比如JDK的垃圾回收线程
-
为什么会有守护线程？何是需要守护线程？
-
明确：JVM什么情况下会退出？
- 官方：The virtual machine exits when the only running are all daemon thread.
- 只有当线程都为守护线程的时候,JVM才会退出(Process finished with exit code 0)
-
守护线程具备自动结束生命周期的特点，非守护线程不具备这样的特点
-
如果垃圾回收线程是一个非守护线程，那么某一个程序完成工作运行结束，JVM无法退出，因为垃圾回收线程依旧工作
注意：先设置守护线程后再启动线程
//测试守护线程
//eg：使用Lambda表达式创建一个线程，使这个线程持续睡觉1ms，主线程睡眠1000ms，然后打印主线程的main方法结束，思考怎样可以让JVM退出
public class TestDaemon extends Thread{
public static void main(String[] args) {
Thread thread=new Thread(()->{
while (true) {
try {
Thread.sleep(1);
System.out.println("子线程睡眠中。。。。");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.setDaemon(true); //设置匿名线程为守护线程，就可以使JVM进程退出
thread.start();
//主线程
try {
Thread.sleep(1000);
System.out.println("主线程睡眠结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Process finished :说明JVM已经退出
线程同步（重点）
努力更新中…
文章如有任何错误，请小伙伴评论区指正哟
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
