下面是AI的回答
Java线程就是Java程序里面可以同时运行多个任务。Java提供了几种创建和管理线程的方式,其中一种是继承Thread类,另一种是实现Runnable接口或Callable接口。jdk5提供了线程池,可以更方便地创建、启动和终止线程。在多线程编程中,需要注意线程安全、死锁、线程阻塞等问题,可以使用synchronized关键字保证线程安全,使用Lock接口和Condition接口避免死锁问题,使用Thread.sleep()方法避免线程阻塞问题。
程序(program):程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
进程(process):进程是程序的一次执行过程,或是正在运行的一个程序。
是一个动态的过程(有生命周期):有它自身的产生、存在和消亡的过程。如:运行中的QQ,运行中的MP3播放器
一道程序可以被执行多次,也就是由一道程序可以同时出现多个进程。
程序是静态的,进程是动态的
进程作为系统资源分配的单位,系统在运行时会为每个进程分配不同的内存区域
线程(thread):进程可进一步细化为线程,是一个程序内部的一条执行路径。
在一个进程内,可以同时执行多条线程。(相当于一段时间内,可以有三台车同时走三条路线)
线程作为系统(CPU)调度和执行的单位。
若一个进程同一时间并行执行多个线程,就是支持多线程的。如一个软件同时打开不同的界面。
一个进程中的多个线程共享相同的内存单元/内存地址空间。
程序、进程、线程的关联?
提示:程序、进程、线程是一个广泛的概念。比如:操作系统也是一道程序、桌面应用也称一道程序。和软件的概念差不多。
理解:用Java的角度
- 一个项目就是一个程序,一个项目的运行就是一个进程,一个项目(进程)可以有多条执行路线(线程)同时执行,
- 从内存的角度上看:一个进程有一片内存区域,线程没有,线程用的是进程的(多个线程共用进程的内存)(线程在进程的范围内活动,线程可以理解为进程的活动轨迹,进程可以理解为程序的活动)
- 一个Java应用程序java.exe进程,其实至少有三个线程:main()主线程,gc()垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。
- JVM本质上是一个程序。
开发体会: 我们在编写Java程序中会必须考虑程序的线程;而进程是由用户系统控制的,我们开发者控制不了,也无须考虑。
理解Java程序的进程:
JVM进程的内存分析:
内存结构:
在一个JVM进程中:每个线程拥有独立的运行栈和程序计数器(pc),换句话说:一个JVM进程有多份栈空间和程序计数器
在一个JVM进程中:多个线程从同一堆中分配对象,换句话说:一个JVM进程只有一份堆空间、一份方法区
一个Java应用程序进程,其实至少有三个线程:main()主线程,gc()垃圾回收线程,异常处理线程。线程之间相互影响。
Java语言的JVM允许程序同时运行多个线程,它通过java.lang.Thread类来体现。
java.lang.Thread:是线程的抽象表示形式。jdk文档中Thread类中就有说明:Thread是程序中的线程。
要想实现多线程,必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程。
Thread类的特性:
每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体
特别的,要通过该Thread对象的start()方法来启动这个线程,而非直接调用run()
想要启用新的线程,必须调用该线程对象的start方法。
start方法的作用:
- 启动当前线程
- 调用当前线程的run()
一个线程对象只能调用一次start()方法启动,如果重复调用了,则将抛出异常:“IllegalThreadStateException”。
如果自己手动调用run()方法,那么就只是普通方法,没有启用新的线程。
run()方法由JVM调用,什么时候调用,执行的过程控制都由操作系统的CPU调度决定。
Thread类的构造器:
Thread()
:创建新的Thread对象Thread(String threadname)
:创建线程并指定线程实例名Thread(Runnable target)
:指定创建线程的目标对象,它实现了Runnable接口中的run方法Thread(Runnable target, String name)
:创建新的Thread对象理解:
- 一个线程在Java中体现为一个Thread类的对象
- 线程的执行内容就是Thread类对象的run()的执行内容
- 如何启动一个线程呢?
4. 调用Thread对象的start()
Thread类的常用方法:即提供了线程相关的功能操作
void start()
: 启动线程,并执行对象的run()方法
void run()
: 线程在被调度时执行的操作
String getName()
: 返回线程的名称
void setName(String name)
:设置该线程名称
static Thread currentThread()
: 返回当前线程。在Thread类及子类中就是this,通常用于主线程和Runnable实现类
static void yield()
: 线程让步,释放当前的CPU执行权
join()
:当某个程序执行流中调用其他线程的 join() 方法时,调用线程将被阻塞,直到 join() 方法加入的 join 线程执行完为止
static void sleep(long millis)
: (指定时间:毫秒)
stop()
: 强制线程生命期结束,不推荐使用。是过时的(Deprecated)
suspend()
:将线程挂起。不推荐使用,容器造成死锁。是过时的(Deprecated)
resume()
:搭配suspend()使用,也是过时的。不推荐使用。
boolean isAlive()
: 返回boolean,判断线程是否还活着
官方API文档中说明了创建子线程的方式
JDK1.5之前创建新执行线程有两种方法:
JDK1.5新增了两者种创建新执行线程的方法:
思考: 为什么不用直接创建Thread类的对象来创建新的线程呢?
答:线程的执行,本质上就是Thread类对象里run()方法的执行,直接创建Thread类虽然创建了新的线程,但并不能让该线程执行想要的操作,失去了意义。所以我们创建Thread类的对象的同时必须想办法重写该对象的run(),将想执行的操作放进去,官方给我们提供了几种方式。
步骤:
举例:输出100以内的偶数
//1.定义子类继承Thread类。
class MyThread extends Thread {
//2.子类中重写Thread类中的run方法。
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.print(i);
}
}
}
public class Test {
public static void main(String[] args) {
//3.创建Thread子类对象,即创建了线程对象。
//4.调用线程对象start方法:启动线程,调用run方法。
//new MyThread().run();//行吗?不行
new MyThread().start();
}
}
//*********************简单化**************************
class Test {
public static void main(String[] args) {
//创建Thread的匿名子类对象
new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.print(i);
}
}
}.start();
}
}
步骤:
定义子类,实现Runnable接口。
子类中重写Runnable接口中的run方法。
创建Runnable接口的子类的对象
通过将Runnable接口的子类对象作为实际参数传递给Thread类的含参构造器中来创建线程对象
调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
//源码中Thread类的run()是这样的。其中target是Thread类的属性:private Runnable target;
//结论:使用含参构造器创建Thread对象,传入Runnable对象时会将对象赋给target,target不为空,run()就会调用target也就是Runnable对象里的run()。
public void run() {
if (target != null) {
target.run();
}
}
落地代码:输出100以内的偶数
//1.定义子类,实现Runnable接口。
class MyThread implements Runnable {
//2.子类中重写Runnable接口中的run方法。
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.print(i);
}
}
}
public class Test {
public static void main(String[] args) {
//3。创建Runnable接口的子类的对象
Runnable r = new MyThread();
//4. 通过将Runnable接口的子类对象作为实际参数传递给Thread类的含参构造器中来创建线程对象
//2. 调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
new Thread(r).start();
}
}
继承方式和实现方式的联系与区别:
联系:Thread类实现了Runnable接口。
//jdk8源码:
public class Thread implements Runnable {
区别:
实现Runnable方式的好处:(开发中推荐使用实现Runnable的方式)
避免了单继承的局限性。
多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。
举例说明:
class Base extends Thread {
public Base(Runnable r) {
super(r);
}
public Base() {}
@Override
public void run() {
System.out.println("这是Base");
}
}
class Sub implements Runnable {
@Override
public void run() {
System.out.println("这是Sub");
}
}
class Test {
public static void main(String[] args) {
Runnable r = new Sub();
new Base(r).start();//这是Base
}
}
与使用Runnable相比,Callable功能更强大些
Future接口
使用Callable接口创建新的线程:
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.重写Callable的Call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() {//可以加throws
//遍历一百以内偶数,并返回所有偶数的和
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
class Test {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为参数,调用FutureTask的含参构造器,创建FutureTask的对象。
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask对象作为参数传递到Thread类的构造器中,创建Thread类的对象,调用start():启动线程,调用call()
new Thread(futureTask).start();
//new Thread(numThread).start();//不行。所以Callable接口需借助FutureTask对象来创建新线程。
try {
//6.可以获取call()的返回值。
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
背景: 经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗、提高资源的重用率(重复利用线程池中线程,不需要每次都创建)
- 便于线程的管理
Java中线程池由相关API体现
JDK 5.0起提供了线程池相关API:ExecutorService 和 Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor。包含一系列操作线程池的方法,
常用方法如下:
void execute(Runnable command)
:执行任务/命令,没有返回值,一般用来执行Runnable Future submit(Callable task)
:执行任务,有返回值,一般用来执行Callablevoid shutdown()
:关闭连接池常见属性:
corePoolSize
:核心池的大小maximumPoolSize
:最大线程数keepAliveTime
:线程没有任务时最多保持多长时间后会终止Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池。
常用方法如下:
Executors.newCachedThreadPool()
:创建一个可根据需要创建新线程的线程池Executors.newFixedThreadPool(n)
; 创建一个可重用固定线程数的线程池Executors.newSingleThreadExecutor()
:创建一个只有一个线程的线程池Executors.newScheduledThreadPool(n)
:创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。线程池的使用:
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class NumThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
}
}
}
class Num2Thread implements Callable {
@Override
public Object call() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
}
return null;
}
}
public class Test {
public static void main(String[] args) {
//1.使用线程池工厂类提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//2.调用新的线程,执行指定的线程操作。需要提供实现Runnable/Callable接口实现类的对象
service.execute(new NumThread());//适用于Runnable
service.submit(new Num2Thread());//适用于Callable
//3.关闭线程池
service.shutdown();
}
}
Java中线程的调度策略:CPU分配给线程的策略
Java线程的优先级
线程的优先级等级
MAX_PRIORITY
:10MIN _PRIORITY
:1NORM_PRIORITY
:5Thread类中涉及优先级的方法:
getPriority()
:返回线程优先值setPriority(int newPriority)
:改变线程的优先级说明:
Java中的线程分为两类:一种是守护线程,一种是用户线程。
说明:
start()
方法前调用thread.setDaemon(true)
可以把一个用户线程变成一个守护线程JDK中用Thread.State类(Thread的内部枚举类)定义了线程的六种状态: NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED
分析理解:要想实现多线程,必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下的五种状态:
图解:
备注:
多线程的安全问题:当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
对于多条操作共享数据的语句:只能让一个线程都执行完,在执行过程中(即使该线程被阻塞),其他线程都不可以参与执行。Java对于多线程的安全问题提供了专业的解决方式:同步机制
语法如下:
同步代码块:操作需要被同步的代码。
synchronized (同步监视器){ //同步监视器自己指定:任意对象。
// 需要被同步的代码;(即操作共享数据的代码)
}
例如:
class W implements Runnable {
private int ticket = 100;
public void run() {
synchronized (this) {
while (ticket > 0) {
System.out.println(currentThread().getName() + "卖票:" + ticket--);
}
}
}
}
synchronized
还可以放在方法声明中,表示整个方法为同步方法。
public synchronized void show() { ... } //发现没有设置同步监视器的地方?同步方法使用的是默认的同步监视器
同步机制的使用说明(总结:注意两点:同步监视器(锁) 、共享数据)
synchronized的锁(同步监视器)是什么? 任意对象都可以作为同步锁。所有对象都自动含有单一的锁(监视器)。
同步方法的锁,是固定的:一个线程类中的所有静态方法共用同一把锁(类名.class),所有非静态方法共用同一把锁(this)
同步代码块的锁:自己指定,开发中很多时候也指定为this或类名.class(类对象)。
锁的使用注意点:必须确保使用同一个资源的多个线程共用一把锁,这个非常重要,否则就无法保证共享资源的安全。
理解:当一个线程A要想进入同步代码中,得先获得该同步代码的锁。只有一把锁时,能保证一个线程在拥有锁并执行的时候,另外的线程得不到锁直到该线程释放锁。若有多把锁时,同样会造成多个线程同时执行语句造成线程安全问题。
class W extends Thread {
private int ticket = 100;
public void run() {
//synchronized(this) {//此时,多个线程并没有共用一把锁,因为每造一个线程,就新建了一个对象
synchronized(W.class) {//此时,能保证多个线程用一把锁,类对象是唯一的!
...
}
}
}
class Test {
public static void main(String[] args) {
new W().start();
new W().start();
}
}
因为同步时被锁住的资源只能被一个线程使用,缺点就是操作同步代码时,只能有一个线程参与,其他线程等待,相当于是一个单线程的过程。所以在使用同步锁的时候需要尽量注意这些问题:
同步的范围:要锁住所有安全问题的代码,尽量避免圈住没有安全问题的代码。
释放锁的情形有:
注意以下操作不会释放锁:
死锁问题
public class DeadLockTest {
public static void main(String[] args) {
final StringBuffer s1 = new StringBuffer();
final StringBuffer s2 = new StringBuffer();
new Thread() {
public void run() {
synchronized (s1) {
s2.append("A");
//极大增加死锁概率:
// try {
// Thread.sleep(1000);
// } catch (Exception e) {
// e.printStackTrace();
// }
synchronized (s2) {
s2.append("B");
System.out.print(s1);
System.out.print(s2);
}
}
}
}.start();
new Thread() {
public void run() {
synchronized (s2) {
s2.append("C");
//极大增加死锁概率:
// try {
// Thread.sleep(1000);
// } catch (Exception e) {
// e.printStackTrace();
// }
synchronized (s1) {
s1.append("D");
System.out.print(s2);
System.out.print(s1);
}
}
}
}.start();
}
}
/**
运行结果?
两种情况:
1.ABABCD
2.死锁
*/
从JDK 5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁可以使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。 锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ,它拥有与 synchronized 相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式地加锁、释放锁
使用:
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
//保证线程安全的代码;
unlock();
}
}
//注意:如果同步代码有异常,要将unlock()写入finally语句块:
lock.lock();
try{
//保证线程安全的代码;
}
finally{
lock.unlock();
}
举例:
class Window extends Thread {
private static ticket = 100;
private static ReentrantLock lock = new ReenTrantLock();//注意:可以为非static吗?在这里不可以,Lock对象充当同步锁,多线程共享统一资源要保证锁的唯一。
public void run() {
lock.lock();
while (ticket > 0) {
System.out.println(currentThread().getName() + "卖票:" + ticket--);
}
lock.unlock();
}
}
synchronized与Lock的对比
开发体会:
优先使用顺序(性能从大到小): Lock —> 同步代码块(已经进入了方法体,分配了相应资源)—> 同步方法(在方法体之外)
ReentrantLock的使用
构造器:
ReentrantLock()
ReentrantLock(Boolean fair)
:如果传参为true:例如线程A、B、C在锁前排队时,如果让A进去了,跑完之后A再回来排队,会让B和C先跑。…
线程之间的通信表现为wait()与notify()和notifyAll() 的使用。
wait()
:令当前线程挂起并放弃CPU、同步资源并等待,使别的线程可访问并修改共享资源(当前线程会释放锁),而当前线程排队等候其他线程调用notify()
或notifyAll()
方法唤醒,唤醒后该线程才会重新进入就绪状态,等待CPU时间的分配。notify()
:唤醒正在排队等待同步资源的线程中优先级最高者结束等待。(只能唤醒一个wait()中的线程)notifyAll ()
:唤醒正在排队等待资源的所有线程结束等待。(唤醒所有wait()中的线程)使用说明:
这三个方法只有在synchronized
方法或synchronized
代码块中才能使用(也不能用在使用Lock对象的同步代码中),否则会报java.lang.IllegalMonitorStateException
异常。
需要注意的是,如果一个线程调用了对象的wait()方法,那么该线程必须先获得该对象的锁才能进入等待状态。如果没有获得该对象的锁,那么会抛出IllegalMonitorStateException异常。此外,如果当前线程被中断,那么会抛出InterruptedException异常。(就是该线程要获得该对象的锁才能执行wait(),然后释放锁)
wait()方法和notify()方法必须在同一个对象上调用,这是因为它们是关联的。如果一个线程调用了对象的wait()方法,那么其他线程必须调用同一对象的notify()方法或notifyAll()方法才能唤醒该线程。
这三个方法的调用者必须是synchronized
方法或synchronized
代码块中的同步监视器。否则报异常。
这三个方法是声明在java.lang.Object
类中的。
因为这三个方法必须由锁对象调用,而任意对象都可以作为synchronized的同步锁,因此这三个方法只能在Object类中声明。
sleep()和wait()的异同?
同:一旦执行方法,都可以使得当前的线程进入阻塞状态。
异: