线程概述
计算机的操作系统采用多任务和分时设计,多任务是指在一个操作系统中可以同时运行多个程序。例如,可以在使用QQ聊天的同时听音乐,即有多个独立运行的任务,每个任务对应一个进程,每个进程也可产生多个线程。
进程
几乎所有的操作系统都支持进程的概念,所有运行中的任务通常对应一个进程(Process)。当一个程序进入内存运行时,即变成了一个进程。进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位。
进程的3个特征:
- 独立性:进程是系统中独立存在的实体,它可以拥有自己独立的资源,每一进程都拥有自己私有的内存地址。在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间。
- 动态性:进程与程序的区别在于, 程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合。在进程中加入时间的概念。进程具有自己的生命周期和各种不同的状态,这些概念在程序中都是不具备的。
- 并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。
注:并发性和并行性是两个概念,并行指在同一个时刻,有多条指令在多个处理器上同时执行;并发指的是同一时刻只能有一条指令执行,但多个进程指令被快速来回切换执行,使得在宏观上具有多个进程同时执行的效果。
多线程的优点:
线程在程序中是独立的,并发的执行流,与分隔的进程相比,进程中线程之间的隔离程度小。它们共享内存,文件句柄和其他进程应用的状态。
因为线程的划分尺度小于进程,使的多线程程序的并发行高。进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大的提高了程序的运行效率。
线程比进程具有更高的性能,这是同一个进程中的线程都有共性——多个线程共享同一个进程虚拟空间。线程共享的环境包括:进程代码段,进程中的公有数据等。利用这些共享的数据,线程之间很容易实现相互之间的通信。
当操作系统创建一个进程时,必须为该进程分配独立的内存空间,并分配大量的相关资源;但创建一个线程则简单的多。因此使用多线程来实现并并发比使用多进程实现并发效率高很多。
总结:多线程编程的几个优点:
- 进程之间不能共享内存,但线程之间共享内存非常容易。
- 系统创建进程时需要为该进程重新分配系统资源,但创建线程则代价小的多。因此使用多线程来实现多任务并发比多进程效率高。
在Java中实现多线程
Java 在类和接口方面为多线程提供内置支持。Java 通过 Thread 类将线程所必须的功能都封装了起来。
Thread 类及其常用方法
java.lang.Thread
类支持多线程编程,该类提供了大量的方法来控制和操作线程。常用方法如下表所示:
方法名称 | 说明 |
---|---|
Thread() |
分配新的 Thread 对象 |
Thread(Runnable target) |
分配新的 Thread 对象,target 为 run() 方法被调用的对象 |
Thread(Runnable target, String name) |
分配新的 Thread 对象,target 为 run() 方法被调用的对象,name 为新线程的名称 |
void run() |
执行任务操作的方法 |
void start() |
使该线程开始执行,Java 虚拟机调用该线程的run() 方法 |
void sleep(long millis) |
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行) |
String getName() |
返回线程的名称 |
int getPriority() |
返回线程的优先级 |
void setPrority(int newPriority) |
更改线程的优先级 |
static Thread currentThread() |
返回当前正在执行的线程对象的引用 |
boolean isAlive() |
测试线程是否处于活动状态 |
void join() |
等待该线程终止 |
void interrupt() |
中断线程 |
void yield() |
暂停当前正在执行的线程对象,并执行其他线程 |
主线程
在 Java 程序启动时,一个线程立刻运行,该线程通常称为程序的主线程。 Java 程序中的 public static void main()
方法是主线程的入口,每个进程都至少有一个主线程。它是程序开始时就执行的。主线程的重要性体现在以下两个方面:
- 它是产生其他子线程的线程。
- 通常它必须最后完成执行,因为它执行各种关闭操作。
尽管主线程在程序启动时自动创建,但它可以由一个 Thread 对象控制。为此,需要调用方法 currentThread()
获得它的一个引用,currentThread()
方法是 Thread 类的公有的静态成员。它的通常形式如下:
static Thread currentThread()
该方法返回一个调用它的线程的引用。一旦获得主线程的引用,就可以像控制其他线程那样控制主线程。
控制主线程代码如下:
public static void main(String[] args) {
Thread t = Thread.currentThread();
System.out.println("当前线程名称:" + t.getName());
//修改主线程名称
t.setName("MyFirstThread");
System.out.println("修改后的线程名称:" + t.getName());
}
//运行结果:
//当前线程名称:Thread-0
//修改后的线程名称:MyFirstThread
Java线程的创建和启动
Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务,实际上就是执行一段顺序的程序流。
继承Thread类来创建线程类
public class FirstThread extends Thread {
//重写run()方法
@Override
public void run() {
super.run();
// 线程执行体...
}
public static void main(String[] args) {
FirstThread firstThread = new FirstThread();
System.out.println("当前线程名称:"
+ firstThread.getName());
firstThread.setName("MyFirstThread");
System.out.println("修改后的线程名称:"
+ firstThread.getName());
firstThread.start();
}
}
//运行结果:
//当前线程名称:Thread-0
//修改后的线程名称:MyFirstThread
实现Runnable接口创建线程类
public class SecondThread implements Runnable {
@Override
public void run() {
//线程执行体...
}
public static void main(String[] args){
SecondThread target=new SecondThread();
//Runnable对象作为Thread的target
Thread thread=new Thread(target);
thread.start();
}
}
使用Callable和Future创建线程
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThirdThread implements Callable<String> {
@Override
public String call() throws Exception {
// 线程执行体..
return "A";
}
public static void main(String[] args) {
try {
ThirdThread thirdThread = new ThirdThread();
FutureTask<String> task = new FutureTask(thirdThread);
// 将构建的FutureTask作为target传入Thread中
new Thread(task).start();
// 获取线程执行的返回值
System.out.println(task.get());
} catch (Exception e) {
e.printStackTrace();
}
}
}
三种Java线程创建方式的对比:
尽量采用实现Runable
,Callable
接口的方式创建多线程
优点:
线程类只是实现了Runable接口或者Callable接口,还可以继承其他类,可以避免由于Java单继承带来的局限性。
这种方式下,多个线程可以共享一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU,代码和数据分开,形成清晰的模型,较好的体现了面向对象的思想。
获取和设置线程名字
getName()
方法:获取线程名字
setName()
方法:设置线程名字
1.可以在run()
方法中设置线程名字
2.可以在MyThread.java(子线程)类的构造方法中,设置线程名字。
演示代码如下:
1.MyThread.java
public class MyThread extends Thread {
public MyThread() {
}
// 构造器设置线程名字
public MyThread(String name) {
super(name);
}
// run()方法获取线程名字
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我是---->" + getName() + ":" + i);
}
}
}
2.Test.java
public class Test {
public static void main(String[] args) {
MyThread t = new MyThread("刘备");
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
//设置线程名字
t1.setName("关羽");
t2.setName("张飞");
t.start();
t1.start();
t2.start();
}
}
线程调度(线程优先级)
线程有两种调度模型:
分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片。
抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些。
问:假如我们的计算机只有一个 CPU,那么 CPU 在某一个时刻只能执行一条指令,线程只有得到 CPU时间片,也就是使用权,才可以执行指令。那么Java是如何对线程进行调用的呢?
答:Java使用的是抢占式调度模型。
演示如何设置和获取线程优先级
final int getPriority()
:获取线程优先级
final void setPriority(int newPriority)
:设置线程优先级,1到10,默认5。
演示代码如下:
1.MyThread.java
public class MyThread extends Thread {
public MyThread() {
}
// 构造器设置线程名字
public MyThread(String name) {
super(name);
}
// run()方法获取线程名字
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我是---->" + getName() + ":" + i);
}
}
}
2.Test.java
public class Test {
public static void main(String[] args) {
MyThread t1 = new MyThread("张飞");
MyThread t2 = new MyThread("关羽");
// 设置线程优先级:1到10,必须在范围内
t2.setPriority(10);
t1.setPriority(1);
// 获取线程优先级
// 主线程优先级 也是线程的默认值5。
System.out.println(Thread.currentThread().getPriority());
// 两个子线程优先级
System.out.println(t1.getPriority());
System.out.println(t2.getPriority());
t1.start();
t2.start();
}
}
注意:由于线程执行有随机性,所以一两次执行不代表正确效果
优先级高的只是获得的时间片更多一些,而不是全部。
常见问题
问:java程序运行默认是有几个线程?单线程还是多线程?
答:JVM运行时,最少启动两个线程:main线程(主线程),GC(垃圾回收)线程。所以是多线程。
一个java程序只有一个主线程 其他开启的都是子线程。
问:如何定义一个线程?
答:
1.找一个类继承Thread
类,或者,采用实现Runable
、Callable
接口的方式创建多线程,覆写run()
方法,run()
方法里面写的就是子线程要运行的代码。
问:子线程中覆写的run()
方法中一般写一些什么?
答:一般在子线程代码会写一个耗时操作,或者,长循环,也就是比较复杂的算法代码。
问:启动线程是哪一个方法,start()
还是run()
?
答:是start()
启动线程。
问:run()
和start()
的区别?
答:
start()
:使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
run()
:调用run方法,就是new普通对象,然后在main方法中,普通对象调用普通方法,单线程运行。
问:线程能不能多次启动?
答:同一个线程对象一辈子只能start()
一次。
如果多次start()
将报错:IllegalThreadStateException
—非法线程状态异常:
常见于一个线程对象start两次。