本文详细介绍了Java中的线程概念，包括程序、进程和线程的定义，线程的创建（通过继承Thread类和实现Runnable接口），线程的优先级、状态和分类。还深入讨论了线程同步（如synchronized和Lock），线程死锁以及线程通信的基本原理。最后提到了Callable接口和FutureTask在创建返回值线程中的应用。
文章目录
一、程序、进程、线程
- 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码.
- 进程((process)就是正在执行的程序,从Windows角度讲，进程是操作系统进行资源分配的最小单位.
- 线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元，隶属于进程.
二、线程和进程的关系
- 一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；
- 每一个进程至少包含一个线程（称为主线程）；在主线程中开始执行程序，java程序的入口main（）方法就是在主线程中被执行的；
- 在主线程中可以创建并启动其他的线程；
- 一个进程内的所有线程共享该进程的内存资源；
三、创建线程
创建线程的方式：
- 继承Thread类的方式
- 实现Runnable接口的方式
继承Thread类的方式：
- 在Java中要实现线程，最简单的方式就是继承Thread类，重写其中的run方法：（继承Thread方法、类就不能继承其他类）
- Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行run方法。
public class MyThread extends Thread{
//重写run方法
@Override
public void run() {
}
public static void main(String[] args) {
//创建线程并调用
MyThread myThread = new MyThread();
myThread.start();
}
}实现Runnable接口的方式：
- java.lang.Runnable接口中仅仅只有一个抽象方法：
public void run()- 也可以通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即可；
- Runnable接口的存在主要是为了解决Java中不允许多继承的问题；
public class ThreadDemo implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("ThreadDemo:"+i);
}
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println("main:"+i);
}
}
}继承方式和实现方式的联系与区别
区别：
- 继承Thread：线程代码存放Thread子类的run方法中。
- 实现Runnable：线程代码存放在接口的子类的run方法中。
实现Runnable的好处：
- 避免了单继承的局限性；
- 多个线程可以共享同一个接口实现类的对象，非常适合多个线程来处理同一份资源
四、Thread类中的方法
Thread类构造方法：
| 构造方法 | 说明 |
|
Thread()
| 创建一个新的线程 |
|
Thread(String name)
|
创建一个指定名称的线程
|
|
Thread(Runnable target)
|
利用Runnable对象创建一个线程，启动时将执行该对象的 run方法
|
|
Thread(Runnable target, String name)
|
利用Runnable对象创建一个线程，并指定该线程的名称
|
常用方法：
| 方法原型 | 说明 |
| void start() | 启动线程 |
| final void setName(String name) | 设置线程的名称 |
| final String getName() | 返回线程的名称 |
| final void setPriority(int newPriority) | 设置线程的优先级 |
|
final int getPriority()
|
返回线程的优先级
|
|
final void join()
throws InterruptedException
|
等待线程终止
|
|
static Thread currentThread()
|
返回对当前正在执行的线程对象的引用
|
|
static void sleep(long millis)
throws InterruptedException
|
让当前正在执行的线程休眠（暂停执行）， 休眠时间由milli s（毫秒）指定
|
五、线程的优先级
- 事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；
- 优先级较高的线程有更多获得CPU的机会，反之亦然；
- 优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；
调度策略
时间片
抢占式：高优先级的线程抢占CPU
Java的调度方法：
同优先级线程组成先进先出队列，使用时间片策略；
对高优先级、使用优先调度的抢占式策略
Thread类有如下3个静态常量来表示优先级：
- MAX_PRIORITY：取值为10，表示最高优先级。
- MIN_PRIORITY：取值为1，表示最底优先级。
- NORM_PRIORITY：取值为5，表示默认的优先级
public class ThreadDemo implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("ThreadDemo:"+i);
//获得当前正在执行的线程对象
System.out.println(Thread.currentThread());
}
}
public static void main(String[] args) {
//创建线程执行任务
ThreadDemo threadDemo = new ThreadDemo();
//创建线程
Thread t = new Thread(threadDemo);
//定义线程名称
Thread t = new Thread(threadDemo,"自定义线程");
//启动线程，在操作系统中注册，加入到就绪队列，并不是立即执行
t.start();
//设置优先级
t.setPriority(10);
//获取优先级
Thread.currentThread().setPriority(1);
System.out.println(t.getPriority());
System.out.println(Thread.currentThread().getPriority());
for (int i = 0; i < 10; i++) {
System.out.println("main:"+i);
}
}
}六、线程状态
线程在它的生命周期会处于不同的状态：
线程状态：
- 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run（）方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
七、线程的分类
Java
中的线程分为两类：用户线程和守护线程
- 用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：
- 只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；
- 只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
- 守护线程的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC(垃圾回收器)，它就是一个很称职的守护者。
- 用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。 因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了
- 注意:设置线程为守护线程必须在启动线程之前，否则会跑出一个IllegalThreadStateException异常
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我是守护线程，默默执行");八、多线程的概念
多线程的概念：
多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务
何时需要多线程：
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
多线程的优点：
- 提高程序的响应.
- 提高CPU的利用率.
- 改善程序结构,将复杂任务分为对个线程,独立运行
多线程的缺点
- 线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；
- 多线程需要协调和管理，所以需要CPU时间跟踪线程；
- 线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题；
九、线程同步
并发与并行
- 并行：在同一个时间节点上，同时发生（真正意义上的同时执行）
- 并发：在一段时间内，对某个事情交替执行.例如卖票,抢购,秒杀看似同时进行,实际是一个一个执行.
多线程同步
- 多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，即各线程间要有先来后到；
同步就是排队+锁：
- 几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；
- 为了保证数据在方法中被访问时的正确性，在访问时加入锁机制
模拟卖票
public class TicketThread extends Thread{
//10张票 加static表示共享资源，只有一份
static int num = 10;
static Object lockFlog = new Object();
@Override
public void run() {
while (true) {
synchronized (lockFlog) {
if (num > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + num);
num--;
} else{
break;
}
}
}
}
public static void main(String[] args) {
TicketThread t1 = new TicketThread();
t1.setName("窗口1");
//设置线程为守护线程，必须在启动前设置，其他用户线程结束，守护线程自动结束
//t1.setDaemon(true);
TicketThread t2 = new TicketThread();
t2.setName("窗口2");
t1.start();
t2.start();
}
}
确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源。
使用synchronized(同步锁)关键字同步方法或代码块。
synchronized(锁对象) {
同步代码
}
//锁对象可以是任何对象，但是对于多个线程必须是同一个.
//在对象中，有一个对象头的区域，在对象头中有一个标志为（锁状态）
//具体实现，由编译后的指令实现控制synchronized还可以放在方法声明中，表示整个方法,为同步方法。
public synchronized void show (String name){
需要被同步的代码;
}
一个线程持有锁会导致其他所有需要此锁的线程挂起；在多线程竞争下,加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题.
十、Lock（锁）
Lock
- 从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁.
十一、线程死锁
死锁
- 同步代码块中死循环、锁一直释放不了
- 同步代码块嵌套，不同线程一直占着对方需要的同步锁不释放
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步 资源，就形成了线程的死锁.
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.
设计时考虑锁的顺序、尽量减少嵌套的加锁交互数量。
public class ThreadDemo extends Thread {
static Object obja = new Object();
static Object objb = new Object();
boolean flag = true;
public ThreadDemo(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (obja) {
System.out.println("if obja");
synchronized (objb) {
System.out.println("if objb");
}
}
} else {
synchronized (objb) {
System.out.println("else objb");
synchronized (obja) {
System.out.println("else obja");
}
}
}
}
public static void main(String[] args) {
ThreadDemo d1 = new ThreadDemo(true);
d1.start();
ThreadDemo d2 = new ThreadDemo(false);
d2.start();
}
}十二、线程通信
线程通讯指的是多个线程通过相互牵制，相互调度，即线程间的相互作用。涉及三个方法：
- .wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
- .notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
- .notifyAll一旦执行此方法，就会唤醒所有被wait的线程。
- 注意： .wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。
十三、新增创建线程方式
实现Callable接口与使用Runnable相比，Callable功能更强大些.
- 相比run（）方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，获取返回结果
接收任务
FutureTask<Integer> futureTask = new FutureTask(任务);创建线程
Thread t = new Thread(futureTask);
t.start();
//获得线程call方法的返回值
Integer val = futureTask.get();代码示例：
public class SumThread implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int num = 0;
for (int i = 0; i < 100; i++) {
num += i;
}
return num;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
SumThread sumThread = new SumThread();
FutureTask<Integer> futureTask = new FutureTask(sumThread);
Thread t = new Thread(futureTask);
t.start();
//获取返回值
Integer sum = futureTask.get();
System.out.println(sum);
}
}
扫一扫
2034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
