☕ Java基础: (7) 多线程技术基础
多线程技术
程序
“程序(Program)”是一个静态的概念,一般对应于操作系统中的一个可执行文件。
进程
执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。
特点:
-
进程是程序的一次动态执行过程, 占用特定的地址空间。
-
每个进程由3部分组成:
cpu、data、code
。每个进程都是独立的,保有自己的cpu时间,代码和数据,即便用同一份程序产生好几个进程,它们之间还是拥有自己的这3样东西,这样的缺点是:浪费内存,cpu 的负担较重。
-
多任务
(Multitasking)
操作系统将CPU时间动态地划分给每个进程,操作系统同时执行多个进程,每个进程独立运行。以进程的观点来看,它会以为自己独占CPU的使用权。 -
进程的查看
Windows系统:
Ctrl+Alt+Del
,启动任务管理器即可查看所有进程。Unix系统:
ps
ortop
。
线程
一个进程可以产生多个线程。同多个进程可以共享操作系统的某些资源一样,同一进程的多个线程也可以共享此进程的某些资源(比如:代码、数据),所以线程又被称为轻量级进程(lightweight process)。
-
一个进程内部的一个执行单元,它是程序中的一个单一的顺序控制流程。
-
一个进程可拥有多个并行的
(concurrent)
线程。 -
一个进程中的多个线程共享相同的内存单元/内存地址空间,可以访问相同的变量和对象,而且它们从同一堆中分配对象并进行通信、数据交换和同步操作。
-
由于线程间的通信是在同一地址空间上进行的,所以不需要额外的通信机制,这就使得通信更简便而且信息传递的速度也更快。
-
线程的启动、中断、消亡,消耗的资源非常少。
![图11-2 线程共享资源示意图.png](https://gitee.com/cenjw/mdimg/raw/master/img/1495786203183970.png)
线程和进程的区别
-
最根本区别:进程是资源分配的单位,线程是调度和执行的单位
-
进程间的切换开销较大(每个进程有独立的code和数据空间【进程上下文】)
-
线程切换开销小(同一进程的线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器PC)
-
多进程:在操作系统中能同时运行多个程序(任务)
-
多线程:在同一应用程序中有多个顺序流同时执行
-
线程是进程的一部分,所以线程被称作【轻量级进程】
-
一个没有线程的进程是可以被看作单线程的,如果一个进程内拥有多个线程,进程的执行过程不是一条线(线程)的,而是多条线(线程)共同完成的。
-
除了CPU之外(线程在运行的时候要占用CPU资源),计算机内部的软硬件资源的分配与线程无关,线程只能共享它所属进程的资源。
进程和程序的区别
- 程序是一组指令的集合,它是静态的实体,没有执行的含义。而进程是一个动态的实体,有自己的生命周期。
- 一个进程肯定与一个程序相对应,并且只有一个,但是一个程序可以有多个进程,或者一个进程都没有。
- 进程还有并发性和交往性。简单地说,进程是程序的一部分,程序运行的时候会产生进程。
Java中实现多线程
通过继承Thread类实现多线程
public class MyThread extends Thread {
// 线程体
public void run() {
try {
// getName() 返回线程名称
System.out.println(this.getName() + ":" + i);
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
MyThread t1 = new MyThread();
t1.start();
MyThread t2 = new MyThread();
t2.start();
}
}
缺点:若自定义类
MyThread
先前就继承了一个类,则无法再继承Thread
类
通过Runnable接口实现多线程
开发中常用Runnable
接口实现多线程,在实现Runnable接口的同时还可以继承某个类。
public class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
sout(Thread.currentThread().getName() + ":" + i);
}
}
public static void main(String[] args) {
//创建线程对象,把实现了Runnable接口的对象作为参数传入
Thread t1 = new Thread(new MyThread());
t1.start();
Thread t2 = new Thread(new MyThread());
t2.start();
}
}
线程状态
一个线程对象在它的生命周期内,需要经历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废弃当一个线程进入死亡状态以后,就不能再回到其它状态了。
终止线程的典型方法(重要)
public class MyThreadCircle implements Runnable {
String name;
boolean live = true; // 标记变量
public static void main(String[] args) {
MyThreadCircle ttc = new MyThreadCircle("线程A:");
Thread t = new Thread(ttc); // 新生状态
t.start(); // 就绪状态
for (int i = 0; i < 100; i++) {
print("主线程:" + i);
}
ttc.terminate();
print("ttc stop");
}
@Override
public void run() {
int i = 0;
while (live) {
print(name + (i++));
}
}
public void terminate() {
live = false;
}
}
暂停线程执行常用方法
sleep()
,(如上Java中实现多线程)可以让正在运行的线程进入阻塞状态,直到休眠时间满了,进入就绪状态yield()
,可以让正在运行的线程直接进入就绪状态,让出CPU的使用权
线程的联合 join()
线程A在运行期间,可以调用线程B的 join()
方法,让线程B和线程A联合。这样,线程A就必须等待线程B执行完毕后,才能继续执行。
public class TestThreadJoin {
public static void main(String[] args) {
System.out.println("线程A就必须等待线程B执行完毕后,才能继续执行");
Thread A = new Thread(new ThreadA());
A.start();
}
}
class ThreadA implements Runnable {
@Override
public void run() {
Thread B = new Thread(new ThreadB());
B.start();
System.out.println("线程A等待线程B执行完毕");
try {
B.join();
} catch (InterruptedException e) {
e.printStackTrace();
// 结束JVM。如果是0则表示正常结束;如果是非0则表示非正常结束
System.exit(1);
}
System.out.println("线程A开始执行\n....");
}
}
class ThreadB implements Runnable {
@Override
public void run() {
System.out.println("线程B开始执行");
try {
for (int i = 0; i < 5; i++) {
System.out.println("线程B执行的第" + (i+1) +"分钟");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程B执行完毕");
}
}
结果:
线程A就必须等待线程B执行完毕后,才能继续执行
线程A等待线程B执行完毕
线程B开始执行
线程B执行的第1分钟
线程B执行的第2分钟
线程B执行的第3分钟
线程B执行的第4分钟
线程B执行的第5分钟
线程B执行完毕
线程A开始执行
....
线程基本信息
线程优先级
-
处于就绪状态的线程,会进入“就绪队列”等待 JVM 来挑选。
-
线程的优先级用数字表示,范围从1到10(1最低),一个线程的缺省优先级是5。
-
使用下列方法获得或设置线程对象的优先级。
int getPriority();
void setPriority(int newPriority);
优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高的线程后调用优先级低的线程。
线程同步
线程同步是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕后,下一个线程再使用。
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突的问题。Java语言提供了专门机制以解决这种冲突,有效避免了同一个数据对象被多个线程同时访问造成的这种问题。
-
synchronized
在方法声明中加入该关键字public synchronized void accessVal(int newVal);
synchronized
方法控制对【对象的类成员变量】的访问:- 每个对象对应一把锁,每个
synchronized
方法都必须获得调用该方法的对象的锁才能执行,否则所属线程阻塞 - 方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放
- 此后被阻塞的线程方能获得该锁,重新进入可执行状态。
- 每个对象对应一把锁,每个
-
synchronized
块synchronized 修饰方法的缺点:另外线程必须等待整个方法执行完毕,将会大大影响效率
synchronized
块可以让我们精确地控制到具体的【成员变量】,缩小同步的范围,提高效率synchronized(syncObj) { // ... }
线程同步实例:
public class TestThreadSync {
}
/*简单表示银行账户*/
class Account {
int money;
String name;
public Account(int money, String name) {
super();
this.money = money;
this.name = name;
}
}
/**/
class Drawing extends Thread {
int drawingMoney; // 取多少钱
Account account; // 取钱的账户
int totalDrawing; // 总共取的钱数
public Drawing(int drawingMoney, Account account){
super();
this.drawingMoney = drawingMoney;
this.account = account;
}
void draw() {
synchronized(account) {
if (account.money - drawingMoney < 0) {
print(this.getName() + " 取款,余额不足");
return ;
}
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.money -= drawingMoney;
totalDrawing += drawingMoney;
}
System.out.println(this.getName() + "-->总共取了:" + totalDrawing);
System.out.println(this.getName() + "-->账户余额:" + account.money);
}
@Override
public void run() {
draw();
}
}
Thread-1,取款,余额不足
Thread-0-->总共取了:80
Thread-0-->账户余额:20
如果没有线程同步机制,两个线程同时操作同一个账户对象:
Thread-0-->总共取了:80
Thread-0-->账户余额:20
Thread-1-->总共取了:80
Thread-1-->账户余额:-60
死锁及解决方案
死锁指的是:
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能进行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。
因此, 某一个同步块需要同时拥有【两个以上对象的锁】时,就可能会发生“死锁”的问题。
案例:“化妆线程”需要同时拥有“镜子对象”、“口红对象”才能运行同步块。那么,实际运行时,“小丫的化妆线程”拥有了“镜子对象”,“大丫的化妆线程”拥有了“口红对象”,都在互相等待对方释放资源,才能化妆。这样,两个线程就形成了互相等待,无法继续运行的“死锁状态”。
死锁的解决方法
死锁是由于“同步块需要同时持有多个对象锁造成”的,要解决这个问题,思路很简单,就是:同一个代码块,不要同时持有两个对象锁。
public class TestDeadLock {
public static void main(String[] args) {
Makeup m1 = new Makeup();
m1.girl = "lily";
m1.flag = 0;
Makeup m2 = new Makeup();
m2.girl = "rose";
m2.flag = 1;
m1.start();
m2.start();
}
}
// 口红类
class Lipstick {
}
// 镜子类
class Mirror {
}
// 化妆类
class Makeup extends Thread {
int flag;
String girl;
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
@Override
public void run() {
doMakeup();
}
void doMakeup() {
if (flag == 0) {
synchronized (lipstick) { // 需要得到口红对象的锁
System.out.println(girl + "拿着口红");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// synchronized (mirror) { // 需要得到镜子的锁
// System.out.println(girl + "拿着镜子");
// }
}
synchronized (mirror) { // 需要得到镜子的锁
System.out.println(girl + "拿着镜子");
}
} else {
synchronized (mirror) {
System.out.println(girl + "拿着镜子");
try {
sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// synchronized (lipstick) {
// System.out.println(girl + "拿着口红");
// }
}
synchronized (lipstick) {
System.out.println(girl + "拿着口红");
}
}
}
}
线程并发协作
一个重要的多线程并发协作模型 “生产者/消费者模式”。
什么是生产者?
生产者指的是负责生产数据的模块(这里模块可能是:方法、对象、线程、进程)。
什么是消费者?
消费者指的是负责处理数据的模块(这里模块可能是:方法、对象、线程、进程)。
什么是缓冲区?
消费者不能直接使用生产者的数据,它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”,消费者从“缓冲区”拿要处理的数据。
![图11-17 生产者消费者示意图.png](https://gitee.com/cenjw/mdimg/raw/master/img/1495792247608300.png)
缓冲区是实现并发的核心,缓冲区的设置有3个好处:
-
实现线程的并发协作
有了缓冲区以后,生产者线程只需要往缓冲区里面放置数据,而不需要管消费者消费的情况;消费者同理。
-
解耦了生产者和消费者
生产者不需要和消费者直接打交道。
-
解决忙闲不均,提高效率
生产者生产数据慢时,缓冲区仍有数据,不影响消费者消费; 消费者处理数据慢时,生产者仍然可以继续往缓冲区里面放置数据 。
在生产者消费者问题中,仅有
synchronized
是不够的:
synchronized
可阻止并发更新同一个共享资源,实现了同步
synchronzied
不能用来实现不同线程之间的通信![]()
【生产者消费者模式代码】
public class TestPCmodel {
public static void main(String[] args) {
// 创建缓冲区对象
SyncStack stack = new SyncStack();
// 创建生产者线程
Producers p = new Producers(stack);
// 创建消费者线程
Consumers c = new Consumers(stack);
p.start();
c.start();
}
}
/* 馒头 */
class Buns {
int id;
public Buns(int id) {
this.id = id;
}
@Override
public String toString() {
return Integer.toString(id);
}
}
/* 缓冲区(馒头筐) */
class SyncStack {
int index;
Buns[] buns = new Buns[10];
synchronized public void push(Buns b) {
// 当馒头筐满了
while (index == buns.length) {
try {
//wait后,线程会将持有的锁释放,进入阻塞状态;
//这样其它需要锁的线程就可以获得锁;
//这里的含义是执行此方法的线程暂停,进入阻塞状态,
//等消费者消费了馒头后再生产。
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 唤醒在当前对象等待池中等待的第一个线程。
//notifyAll叫醒所有在当前对象等待池中等待的所有线程
this.notify(); // 如果不唤醒的话。以后这两个线程都会进入等待线程,没有人唤醒
buns[index] = b;
index++;
}
synchronized public Buns pop() {
while (index == 0) { //如果馒头筐是空的;
try {
//等生产线程生产完再来消费;
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
index--;
return buns[index];
}
}
// 生产者线程
class Producers extends Thread {
SyncStack stack = null;
public Producers(SyncStack stack) {
this.stack = stack;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
Buns b = new Buns(i);
stack.push(b);
System.out.println("生产馒头" + b);
}
}
}
// 消费者线程
class Consumers extends Thread {
SyncStack stack = null;
public Consumers(SyncStack stack) {
this.stack = stack;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
Buns b = stack.pop();
System.out.println("消费馒头" + b);
}
}
}
本文来自博客园,作者:micromatrix,转载请注明原文链接:https://www.cnblogs.com/cenjw/p/multithreading-tec.html
posted on 2022-03-10 15:22 micromatrix 阅读(55) 评论(0) 编辑 收藏 举报