单核CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。微观上这些程序是分时的交替运行,只不过是给人的感觉是同时运行,那是因为分时交替运行的时间是非常短的。
只有在多核 CPU 系统中,这些程序彩色真正意义上的的同时执行。
目前电脑市场上说的多核 CPU,便是多核处理器,核越多,并行处理的程序越多,能大大的提高电脑运行的效率。通过任务管理器可以很方便地查看自己电脑CPU的核数,如下图所示。
程序(program):一段代码。静态的。
进程(process):一个正在运行的一个程序。动态的。进程是资源分配的最小单位,有独立的内存空间,即进程中的数据存放空间(堆空间和栈空间)是独立的。
线程(thread):是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小。线程堆空间是共享的(这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。),栈空间是独立的,线程消耗的资源比进程小的多。
tips:
- 一个进程中的多个线程是并发运行的,从微观角度看也是有先后顺序的,哪个线程执行完全取决于 CPU 的调度,程序员是干涉不了的。而这也就造成的多线程的随机性。
- 一个Java应用程序java.exe,其实至少有三个线程:main()主线程,gc()
垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。- 由于创建一个线程的开销比创建一个进程的开销小的多,那么我们在开发多任务运行的时候,通常考虑创建多线程,而不是创建多进程。
使用单个线程先后完成多个任务(调用多个方法),比用多个线程来完成用的时间更短,但是多线程编程具有以下优点:
在程序需要同时执行两个或多个任务;程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等;需要一些后台运行的程序时,我们就需要多线程编程。
Java
语言的JVM
允许程序运行多个线程,它通过java.lang.Thread
类来实现。
public Thread()
:分配一个新的线程对象。public Thread(String name)
:分配一个指定名字的新的线程对象。public Thread(Runnable target)
:分配一个带有指定目标新的线程对象。public Thread(Runnable target,String name)
:分配一个带有指定目标新的线程对象并指定名字。静态方法
public static Thread currentThread()
:返回对当前正在执行的线程对象的引用。public static void sleep(long millis)
使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)public static void yield()
:线程让步。暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程;若队列中没有同优先级的线程,忽略此方法。实例方法
public String getName()
:获取当前线程名称。public void setName(String name)
:设置该线程名称public void start()
:导致此线程开始执行; Java虚拟机调用此线程的run方法。public void run()
:此线程要执行的任务在此处定义代码。public final void join()
:当某个程序执行流中调用其他线程的 join() 方法时,调用线程将被阻塞,直到 join() 方法加入的 join 线程执行完为止(低优先级的线程也可以获得执行)public final void stop()
: 强制线程生命期结束,不推荐使用public final boolean isAlive()
:返回boolean,判断线程是否还活着具体步骤:
Thread
类,并重写该类的构造器(根据需求选择是否重写)以及run()
方法,run()
方法的方法体就代表了线程需要完成的任务,因此将其称为线程执行体。Thread
子类的实例,即创建了线程对象。start()
方法来启动该线程。优缺点
优点:编码简单,如果需要访问当前线程,则无须使用Thread.currentThread()
方法,直接使用this
即可获得当前线程。
缺点:线程类已经继承了Thread
类无法继承其他类了,功能不能通过继承拓展(单继承的局限性)
代码示例:
public class ThreadDemo {
// 启动后的ThreadDemo当成一个进程。
// main方法是由主线程执行的,理解成main方法就是一个主线程
public static void main(String[] args) {
// 3.创建一个线程对象
Thread t = new MyThread();
// 4.调用线程对象的start()方法启动线程,最终还是执行run()方法
t.start();
for(int i = 0 ; i < 10 ; i++ ){
System.out.println("main线程:"+i);
}
}
}
// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
// 2.重写run()方法
@Override
public void run() {
// 线程执行体
for(int i = 0 ; i < 10 ; i++ ){
System.out.println("子线程:"+i);
}
}
}
运行结果:
说明:每次运行的结果都有所差异(并发随机性),也会出现某个线程全部执行完才执行另一个线程的情况。
main线程输出:0
main线程输出:1
main线程输出:2
main线程输出:3
main线程输出:4
子线程输出:0
main线程输出:5
子线程输出:1
子线程输出:2
子线程输出:3
main线程输出:6
main线程输出:7
子线程输出:4
main线程输出:8
main线程输出:9
子线程输出:5
子线程输出:6
子线程输出:7
子线程输出:8
子线程输出:9
tips:
- 想要启动多线程,必须调用start方法。如果自己手动调用run()方法,那么就只是普通方法,没有启动多线程模式,此时将只有主线程在执行他们。start()方法底层其实是给CPU注册当前线程,并且触发run()方法执行,run()方法由JVM调用,什么时候调用,执行的过程控制都由操作系统的CPU 调度决定。
- 一个线程对象只能调用一次start()方法启动,如果重复调用了,则将抛出以上的异常“IllegalThreadStateException”。
- 建议线程先创建子线程,主线程的任务放在之后。否则主线程永远是先执行完!
具体步骤:
优缺点
Runnable方式避免了单继承的局限性;实现解耦操作,线程任务代码可以被多个线程共享,代码和线程独立;线程池只能放入实现Runable或Callable类线程(语法上:Thread作为Runable接口的实现类,其对象实例也能放入线程池)。但是,Runnable方式的代码与继承Thread方式相比复杂了一丢丢,如果需要访问当前线程,则必须使用Thread.currentThread()方法。
代码示例:
// 1。定义子类,实现Runnable接口
class MyRunnable implements Runnable{
// 2.重写该接口的run()方法
@Override
public void run() {
// 线程执行体
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
}
public class Demo {
public static void main(String[] args) {
// 3.创建自定义类对象(线程任务对象)
MyRunnable mr = new MyRunnable();
// 4.创建线程对象
Thread t = new Thread(mr, "子线程");
// 5.调用线程对象的start()方法启动线程,最终还是执行run()方法
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程: " + i);
}
}
}
匿名内部类写法:
public class Demo {
public static void main(String[] args) {
// 1.创建自定义类对象(线程任务对象)
Runnable runnable = new Runnable() {
@Override
public void run() {
// 线程执行体
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
};
// 2.创建线程对象
Thread t = new Thread(runnable, "子线程");
// 3.调用线程对象的start()方法启动线程,最终还是执行run()方法
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程: " + i);
}
}
}
运行结果:
main线程: 0
子线程: 0
main线程: 1
子线程: 1
main线程: 2
子线程: 2
子线程: 3
子线程: 4
子线程: 5
main线程: 3
main线程: 4
main线程: 5
main线程: 6
main线程: 7
main线程: 8
main线程: 9
子线程: 6
子线程: 7
子线程: 8
子线程: 9
JDK5.0
新增线程创建方式
具体步骤:
Callable
接口 , 申明线程执行的结果类型,并重写线程任务类的call
方法。Callable
实现类的实例。Callable
的线程任务对象实例包装成一个FutureTask
未来任务对象实例,并以此实例作为Thread的target来创建Thread对象。start()
方法启动线程。优缺点:
Callable
方式具有Runnable
方式的所有优点。除此之外,Callable
方式还支持泛型的返回值、方法能抛出异常。但Callable
方式的编码较为复杂。
代码示例:
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个Callable的线程任务对象
Callable<String> call = new MyCallable();
// 4.把Callable任务对象包装成一个未来任务对象
// 未来任务对象是啥,有啥用?
// 未来任务对象其实就是一个Runnable对象(底层同时实现了Runnable, Future接口)
// FutureTask既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值
FutureTask<String> task = new FutureTask<>(call);
// 5.把未来任务对象包装成线程对象
Thread t = new Thread(task, "子线程");
// 6.启动线程对象
t.start();
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+": " + i);
}
// 在最后去获取线程执行的结果,如果线程没有结果,让出CPU等线程执行完再来取结果
try {
String rs = task.get(); // 获取call方法返回的结果(正常/异常结果)
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 1.创建一个线程任务类实现Callable接口,泛型指的是线程返回的结果类型
class MyCallable implements Callable<String>{
// 2.重写线程任务类的call方法!
@Override
public String call() throws Exception {
// 需求:计算1-10的和返回
int sum = 0 ;
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+": " + i);
sum+=i;
}
return Thread.currentThread().getName()+"执行的结果是:"+sum;
}
}
运行结果:
main: 7
main: 8
main: 9
main: 10
子线程: 1
子线程: 2
子线程: 3
子线程: 4
子线程: 5
子线程: 6
子线程: 7
子线程: 8
子线程: 9
子线程: 10
子线程执行的结果是:55
实际上所有的多线程代码都是通过运行Thread
的start()
方法来运行的。因此,不管是继承Thread
类还是实现Runnable
接口来实现多线程,最终还是通过Thread
的对象的API来控制线程的,熟悉Thread
类的API是进行多线程编程的基础。
线程优先级:
MAX_PRIORITY
:10MIN _PRIORITY
:1NORM_PRIORITY
:5涉及的方法:
getPriority()
:返回线程优先值setPriority(int newPriority)
:改变线程的优先级说明:
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低,并非一定是在高优先级线程之后才被调用
Java中的线程分为两类:一种是守护线程,一种是用户线程。
JVM
何时离开。start()
方法前调用thread.setDaemon(true)
可以把一个用户线程变成一个守护线程。Java
垃圾回收就是一个典型的守护线程。JVM
中都是守护线程,当前JVM
将退出。线程的完整的生命周期中通常要经历如下的五种状态:
java.lang.Thread.State
这个枚举类中给出了六种线程状态,与传统的五种状态一些许差异,可以通过IDEA等集成开发环境查看java源码,下面给出了源码翻译:
start
方法。MyThread t = new MyThread
只有线程对象,没有线程特征。wait
(不带参数)后会进入Waiting状态,等待另一个线程执行一个(唤醒)动作时。进入这个状态后是不能自动唤醒的,必须等待另一个线程调用notify
或者notifyAll
方法才能够唤醒。锁会释放。Thread.sleep
、Object.wait
(带参数)。锁不会释放。run
方法正常退出而死亡,或者因为没有捕获的异常终止了run
方法而死亡。多个线程同时操作同一个共享资源时可能会出现线程安全问题。
一个经典的例子:多个用户同时取同一个账户中的钱。
线程安全问题大多是由 全局变量 及 静态变量 引起的,局部变量逃逸也可能导致线程安全问题。
如果多线程程序每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,那这个程序就是线程安全的。
核心思想:让多个线程实现先后依次访问共享资源。也就是说在某个线程修改共享资源的时候,其他线程不能修改该资源,等待修改完毕同步之后,才能去抢夺CPU资源,完成对应的操作。
下面就来介绍以下java实现线程同步的三种方式。
代码格式:
synchronized (同步锁对象){
// 可能会产生线程安全问题的代码
}
tips:
- 锁对象可以是任意类型。
- 多个线程对象要使用同一把锁。
- 锁对象建议使用共享资源。在实例方法中建议使用
this
作为锁对象;在静态方法中建议使用类名.class
作为锁对象。- 锁的范围在锁住所有有安全问题的代码的前提下,越小越好。
使用synchronized
修饰的方法,就叫做同步方法,保证某个线程执行该方法时,其他线程只能在方法外等着。
同步方法的原理和同步代码块的底层原理其实是完全一样的,只是同步方法是把整个方法的代码都锁起来的。
同步方法其实底层也是有锁对象的:如果方法是实例方法:同步方法默认用this
作为的锁对象;如果方法是静态方法:同步方法默认用类名.class
作为的锁对象。
public synchronized void method(){
// 可能会产生线程安全问题的代码
}
从JDK 5.0
开始,Java
提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock
接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock
对象加锁,线程开始访问共享资源之前应先获得Lock
对象。
ReentrantLock
类实现了 Lock
,是可重入、互斥、实现了Lock
接口的锁,它与synchronized
具有相同的基本行为和语义,并且扩展了其能力。
Lock锁也称同步锁,加锁与释放锁方法化了,如下:
public void lock()
:加同步锁。public void unlock()
:释放同步锁。代码格式:
class Demo{
private final Lock lock = new ReenTrantLock();
public void method(){
lock.lock(); // 上锁
try{
// 可能会产生线程安全问题的代码
}catch (Exception e){
e.printStackTrace();
}finally{
lock.unlock(); // 解锁
}
}
}
tips:
如果同步代码有异常,要将unlock()写入finally语句块。
Lock
是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized
是隐式锁,出了作用域自动释放。使用Lock
锁,JVM
将花费较少的时间来调度线程,性能更好,并且具有更好的扩展性(提供更多的子类)。
优先级:
Lock(拓展性好) > 同步代码块(作用范围较小) > 同步方法(作用范围较大)
释放锁的操作
break
、return
终止了该代码块的继续执行。Error
或Exception
,导致异常结束。wait()
方法,当前线程暂停,并释放锁。不会释放锁的操作
Thread.sleep()
、Thread.yield()
方法暂停当前线程的执行。suspend()
方法将该线程挂起,该线程不会释放锁(同步监视器)。suspend()
和resume()
来控制线程,容易造成死锁。线程通信实际上是一种等待唤醒机制。
wait()
:令当前线程挂起并放弃CPU、同步资源并等待,使别的线程可访问并修改共享资源,而当前线程排队等候其他线程调用notify()
或notifyAll()
方法唤醒,唤醒后等待重新获得对监视器的所有权后才能继续执行。notify()
:唤醒正在排队等待同步资源的线程中优先级最高者结束等待。notifyAll ()
:唤醒正在排队等待资源的所有线程结束等待。tips:
- 线程通信前一定要保证线程安全,否则毫无意义。
- 这三个方法只有在
synchronized方法
或synchronized代码块
中才能使用,否则会报java.lang.IllegalMonitorStateException
异常。- 因为这三个方法必须有锁对象调用,而任意对象都可以作为synchronized的同步锁,因此这三个方法只能在Object类中声明。