一 (线程的介绍)
1 多线程的基本概念
(每个进程由三部分构成——>CPU,Data,Code,进程之间完全独立,内存隔离)
(运行在进程内的,一个进程可以包含多个线程,线程之间是可以并行的,并且共享相同的内存单元的地址空间,可以访问一个进程内的相同的变量和对象的,他们从同一堆当中分配对象并进行通讯)
1 什么是程序?
程序(Program)是一个静态的概念,一般对应于操作系统中的一个b。
2 什么是进程?
每个进程由三部分构成——>CPU,Data,Code,进程之间完全独立,内存隔离。
八核——>其实物理上还是一个CPU,只不过通过算法模拟出了八核。
执行中的程序叫做进程(Process),是一个动态的概念。其实进程就是一个在内存中独立运行的程序空间 。
现代操作系统比如Mac OS X,Linux,Windows等,都是支持“多任务”的操作系统,叫“多任务”呢?简单地说,就是操作系统可以同时运行多个任务。打个比方,你一边在用逛淘宝,一边在听音乐,一边在用微信聊天,这就是多任务,至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着,只是桌面上没有显示而已。
3 什么是线程?
运行在进程内的,一个进程可以包含多个线程,线程之间是可以并行的,并且共享相同的内存单元的地址空间,可以访问一个进程内的相同的变量和对象的,他们从同一堆当中分配对象并进行通讯
线程(Thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。
有些进程还不止同时干一件事,比如微信,它可以同时进行打字聊天,视频聊天,朋友圈等事情。在一个进程内部,要同时干多件事,就需要同时运行多个“子任务”,我们把进程内的这些“子任务”称为线程(Thread)
2 进程、线程的区别
(线程是程序执行的最小单位,而进程是操作系统分配资源的最小单位)
(线程上下文切换比进程上下文切换要快得多)
一个故事说明进程、线程的关系:
乔布斯想开工厂生产手机,费劲力气,制作一条生产线,这个生产线上有很多的器件以及材料。一条生产线就是一个进程。
只有生产线是不够的,所以找五个工人来进行生产,这个工人能够利用这些材料最终一步步的将手机做出来,这五个工人就是五个线程。
为了提高生产率,有两种办法:
- 一条生产线上多招些工人,一起来做手机,这样效率是成倍増长,即单进程多线程方式
- 多条生产线,每个生产线上多个工人,即多进程多线程
- 线程是程序执行的最小单位,而进程是操作系统分配资源的最小单位;
- 一个进程由一个或多个线程组成,线程是一个进程中代码的不同执行路线;
- 进程之间相互独立,但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号),某进程内的线程在其它进程不可见;
- 调度和切换:线程上下文切换比进程上下文切换要快得多。
3 什么是并发
(多个线程运行时——>CPU只有一个——>采用时间片轮询算法,交替运行——>每次时间分配都不一样)
(弄清楚——>串行,并行,并发)
并发是指在一段时间内同时做多个事情。当有多个线程在运行时,如果只有一个CPU,这种情况下计算机操作系统会采用并发技术实现并发运行,具体做法是采用“ 时间片轮询算法”,在一个时间段的线程代码运行时,其它线程处于就绪状。这种方式我们称之为并发。(Concurrent)。
- 串行(serial):一个CPU上,按顺序完成多个任务
- 并行(parallelism):指的是任务数小于等于cpu核数,即任务真的是一起执行的
- 并发(concurrency):一个CPU采用时间片管理方式,交替的处理多个任务。一般是是任务数多余cpu核数,通过操作系统的各种任务调度算法,实现用多个任务“一起”执行(实际上总有一些任务不在执行,因为切换任务的速度相当快,看上去一起执行而已)
4 线程的执行特点
(调用方法——>串行化——>有等待的过程)
(启动线程——>并列运行——>谁也不等谁)
1 方法的执行特点
2 线程的执行特点
5 主线程和子线程
(Jvm在操作系统中就是基于一个进程来运行的,一个进程至少要有一个线程——>main主线程)
(JVM会通过操作系统开辟一条main方法通向cpu的执行路径)
(对于主线程main来说,其他的线程都是子线程)
1 主线程
当Java程序启动时,一个线程会立刻运行,该线程通常叫做程序的主线程(main thread),即main方法对应的线程,它是程序开始时就执行的。
Java应用程序会有一个main方法,是作为某个类的方法出现的。当程序启动时,该方法就会第一个自动的得到执行,并成为程序的主线程。也就是说,main方法是一个应用的入口,也代表了这个应用的主线程。JVM在执行main方法时,main方法会进入到栈内存,**JVM会通过操作系统开辟一条main方法通向cpu的执行路径,cpu就可以通过这个路径来执行main方法,**而这个路径有一个名字,叫main(主)线程
2 主线程的特点
它是产生其他子线程的线程。
它不一定是最后完成执行的线程,子线程可能在它结束之后还在运行。
3 子线程
在主线程中创建并启动的线程,一般称之为子线程。
二 (线程的创建)
6 Thread类实现多线程
(java.lang.Thread 类——>缺点java中不支持多继承,所以后续提供了接口)
(实例化Thread对象——>重写run( )方法(线程体只能写在run里面)——>不能被调用——>通过start()方法开启)
(时间片分配时间每次都不一样)
继承Thread类实现多线程的步骤:
-
在Java中负责实现线程功能的类是java.lang.Thread 类。
此种方式的缺点: 如果我们的类已经继承了一个类(如小程序必须继承自 Applet 类),则无法再继承 Thread 类。
-
可以通过创建 Thread的实例来创建新的线程。
-
每个线程都是通过某个特定的Thread对象所对应的方法run( )来完成其操作的,方法run( )称为线程体。
-
通过调用Thread类的start()方法来启动一个线程。
通过继承Thread类实现多线程
package testthread;
public class TestMyThread {
public static void main(String[] args) {
System.out.println("-----main...start------");
//创建线程对象
MyThread mt = new MyThread();
//开启线程:调用Start方法,Jvm自动调用run方法
mt.start();
for(int i = 0;i<=200;i++){
System.out.println("~~~~~~~~~主线程~~~~~~~~~~~"+i);
}
System.out.println("main----end-------");
}
}
class MyThread extends Thread{
//线程的执行体,任务代码定义在当前的方法中
public void run(){
for(int i = 0;i<=200;i++){
System.out.println("++++++mt线程+++++++"+i);
}
}
}
交替执行,而且每次执行结果都不一样,时间片分配不一样
7 Runnable接口实现多线程
(!包装成线程对象!)——>(!!!线程启动——>因为启动方法在Thread里面,所以要用Thread的构造方法——>实现了Runnable接口的对象作为参数传入!!!)
(接口里面只有一个抽象方法run();,如果使用Thread里面的方法就只能使用静态方法了)
(通常使用Runnable接口多一些,因为它克服了继承的缺点)
(Thread.currentThread().getName() 静态方法,获取线程信息)
(重写run方法不许有参数)
在开发中,我们应用更多的是通过Runnable接口实现多线程。这种方式克服了继承Thread类的缺点,即在实现Runnable接口的同时还可以继承某个类。
从源码角度看,Thread类也是实现了Runnable接口。Runnable接口的源码如下:
public interface Runnable {
void run();
}
两种方式比较看,实现Runnable接口的方式要通用一些。
通过Runnable接口实现多线程
public class TestThread2 implements Runnable {//自定义类实现Runnable接口;
//run()方法里是线程体;
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
public static void main(String[] args) {
//创建线程对象,把实现了Runnable接口的对象作为参数传入;
Thread thread1 = new Thread(new TestThread2());
thread1.start();//启动线程;
Thread thread2 = new Thread(new TestThread2());
thread2.start();
}
}
示例2:
package testthread;
public class TestRunnable {
public static void main(String[] args) {
System.out.println("-----main...start......1");
Thread t1 = new Thread(new MyTarger()); //核心!!!
t1.start();
for(int i = 0;i<=200;i++){
System.out.println("~~~~~~~~~主线程~~~~~~~~~~~"+i);
}
System.out.println("main----end-------");
}
}
class MyTarger implements Runnable{
//定义线程任务
@Override
public void run() {
for(int i = 0;i<=200;i++){
System.out.println("------Runnable--2------"+i);
}
}
}
8 线程的执行流程
(解除阻塞之后要等待才会继续运行)
- 新建(New):
- 当一个线程对象被创建,但还没有调用
start()
方法时,线程处于新建状态。在这个阶段,线程还没有被初始化,也没有分配任何资源。
- 当一个线程对象被创建,但还没有调用
- 就绪(Ready):
- 调用线程的
start()
方法后,线程进入就绪状态。此时,线程已经被初始化,并且已经准备好执行。线程调度器会从就绪状态的线程中选择一个来执行。
- 调用线程的
- 运行(Running):
- 线程调度器选择一个就绪状态的线程来执行,线程进入运行状态。在单核处理器上,同一时刻只有一个线程可以处于运行状态;在多核处理器上,可以有多个线程同时处于运行状态。
- 线程在运行状态下执行
run()
方法中的代码。
- 阻塞(Blocking):
- 线程在执行过程中可能会因为某些原因而无法继续执行,进入阻塞状态。这通常发生在以下几种情况:
- 线程试图获取一个当前不可用的资源,如同步锁。
- 线程执行了
Thread.sleep()
方法,主动让出CPU一段时间。 - 线程执行了
Object.wait()
方法,等待另一个线程的通知。 - 线程执行了I/O操作,正在等待I/O完成。
- 阻塞状态下的线程不会占用CPU资源。
- 线程在执行过程中可能会因为某些原因而无法继续执行,进入阻塞状态。这通常发生在以下几种情况:
- 等待(Waiting):
- 线程执行
Object.wait()
方法后进入等待状态,直到另一个线程调用相同对象的Object.notify()
或Object.notifyAll()
方法。等待状态下的线程需要被显式唤醒。
- 线程执行
- 计时等待(Timed Waiting):
- 线程执行
Thread.sleep()
方法,或者Object.wait()
方法带有超时参数,或者LockSupport.parkNanos()
、LockSupport.parkUntil()
等方法后,进入计时等待状态。计时等待状态的线程会在指定的时间后自动返回到就绪状态。
- 线程执行
- 终止(Terminated):
- 线程完成
run()
方法的执行后,进入终止状态。线程一旦终止,就不能被重启或恢复。 - 线程也可以因为异常而提前终止,比如在
run()
方法中抛出了一个未捕获的异常。
- 线程完成
- 状态转换:
- 新建到就绪:调用线程的
start()
方法。 - 就绪到运行:线程调度器选择线程执行。
- 运行到阻塞:线程等待资源或执行特定的方法(如
sleep()
、wait()
)。 - 运行到等待:线程执行
Object.wait()
方法。 - 运行到计时等待:线程执行
Thread.sleep()
或带有超时参数的Object.wait()
方法。 - 阻塞、等待、计时等待到就绪:线程等待的条件得到满足,或者计时结束。
- 运行到终止:
run()
方法执行完毕,或者线程因为异常而提前终止。
- 新建到就绪:调用线程的
9 线程的状态和生命周期
(一个线程对象在它的生命周期内,需要经历5个状态)
一个线程对象在它的生命周期内,需要经历5个状态。
-
新生状态(New)
用new关键字建立一个线程对象后,该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间,通过调用start方法进入就绪状态。
-
就绪状态(Runnable)
处于就绪状态的线程已经具备了运行条件,但是还没有被分配到CPU,处于“线程就绪队列”,等待系统为其分配CPU。就绪状态并不是执行状态,当系统选定一个等待执行的Thread对象后,它就会进入执行状态。一旦获得CPU,线程就进入运行状态并自动调用自己的run方法。有4种原因会导致线程进入就绪状态:
- 新建线程:调用start()方法,进入就绪状态;
- 阻塞线程:阻塞解除,进入就绪状态;
- 运行线程:调用yield()方法,直接进入就绪状态;
- 运行线程:JVM将CPU资源从本线程切换到其他线程。
-
运行状态(Running)
在运行状态的线程执行自己run方法中的代码,直到调用其他方法而终止或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束,就会被系统给换下来回到就绪状态。也可能由于某些“导致阻塞的事件”而进入阻塞状态。
-
阻塞状态(Blocked)
阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪)。
有4种原因会导致阻塞:
- 执行sleep(int millsecond)方法,使当前线程休眠,进入阻塞状态。当指定的时间到了后,线程进入就绪状态。
- 执行wait()方法,使当前线程进入阻塞状态。当使用nofity()方法唤醒这个线程后,它进入就绪状态。
- 线程运行时,某个操作进入阻塞状态,比如执行IO流操作(read()/write()方法本身就是阻塞的方法)。只有当引起该操作阻塞的原因消失后,线程进入就绪状态。
- join()线程联合: 当某个线程等待另一个线程执行结束后,才能继续执行时,使用join()方法。
-
死亡状态(Terminated)
死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它run()方法内的全部工作; 另一个是线程被强制终止,如通过执行stop()或destroy()方法来终止一个线程(注:stop()/destroy()方法已经被JDK废弃,不推荐使用)。
当一个线程进入死亡状态以后,就不能再回到其它状态了。