文章目录
线程简介
- 线程就是独立的执行路径
- 再程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程(垃圾回收)
- main()称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
- 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
- 线程会带来额外的开销,如cpu调度时间,并发控制开销。
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
线程实现
怎么实现的?
- 自定义线程类继承Thread类
- 重写==run()==方法,编写线程执行体
- 创建线程对象,调用==start()==方法启动线程
创建线程两种方法(还有3、通过Callable和FutureTask创建线程,4、通过线程池创建线程)
-
一个是将一个类声明为
Thread
的子类。 这个子类应该重写run
类的方法Thread
。 然后可以分配并启动子类的实例。 -
class PrimeThread extends Thread { long minPrime; PrimeThread(long minPrime) { this.minPrime = minPrime; } public void run() { // compute primes larger than minPrime . . . } } // 然后,以下代码将创建一个线程并启动它运行: PrimeThread p = new PrimeThread(143); p.start();
-
另一种方法来创建一个线程是声明实现类
Runnable
接口。 那个类然后实现了run
方法。 然后可以分配类的实例,在创建Thread
时作为参数传递,并启动。 -
// 推荐使用Runnable class PrimeRun implements Runnable { long minPrime; PrimeRun(long minPrime) { this.minPrime = minPrime; } public void run() { // compute primes larger than minPrime . . . } } //然后,以下代码将创建一个线程并启动它运行: PrimeRun p = new PrimeRun(143); new Thread(p).start();
-
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程,子类对象.start()
- 不建议使用:避免OPP单继承局限性
-
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程:传入目标对象+Thread对象.stat()
- 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
// 模拟龟兔赛跑
public class Race implements Runnable {
// 胜利者
private static String winner;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
// 模拟兔子睡觉
if(Thread.currentThread().getName.equals("兔子") && i%10 == 0) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 判断比赛是否结束
boolean flag = gameOver(i);
// 如果比赛结束了,就停止程序
if(flag) {
break;
}
System.out.println(Thread.currentThread().getName()+ "--->跑了" + i + “步”);
}
}
// 判断是否完成比赛
private boolean gameOver(int step) {
if (winner != null) {
return true;
}else {
if (step >= 100) {
winner = Thread.currentThread().getName();
System.out.println("winner is" + winner);
return true;
}
}
return false;
}
public static void main(Stirng[] args) {
Race rece = new Race();
new Thread(race, "兔子").start();
new Thread(race, "乌龟").start();
}
}
- 实现Callable接口(了解)
线程状态
- 创建状态
- 就绪状态
- 运行状态
- 阻塞状态
- 死亡状态
public static enum Thread.State extends Enum<Thread.State>
线程状态。线程可以处于以下状态之一:
NEW
尚未启动的线程处于此状态。RUNNABLE
在Java虚拟机中执行的线程处于此状态。BLOCKED
被阻塞等待监视器锁定的线程处于此状态。WAITING
正在等待另一个线程执行特定动作的线程处于此状态。TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。TERMINATED
已退出的线程处于此状态。一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。
setPriority
public final void setPriority(int newPriority)
更改此线程的优先级。
首先调用这个线程的checkAccess
方法,没有参数。 这可能会导致投掷SecurityException
。
否则,该线程的优先级设置为指定的小newPriority
和最大允许的线程的线程组的优先级。
线程休眠:
- sleep(时间)指定当前线程阻塞的毫秒数
- sleep存在异常InterruptedException
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时、倒计时等
- 每一个对象都有一个锁,sleep不会释放锁
线程礼让:
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转化为就绪状态
- 让cpu重新调度,礼让不一定成功!看cpu心情
public class TestYield {
public static void main(Stirng[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start;
new Thread(myYield,"b").start;
}
}
class MyYield implements Tunnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程开始执行");
Thread.yield(); // 礼让
System.out.println(Thread.currentThread().getName() + "线程停止执行");
}
}
Join
-
Join合并线程,待此线程执行完成后,在执行其他线程,其他线程阻塞。
-
// join方法,想象为插队 public class TestJoin implements Runnable { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("要插队的线程来了"); } } public static void main (String[] args) { // 启动线程 TestJoin testJoin = new TestJOin(); Thread thread = new Thead(testJoin); thread.start(); // 主线程 for (int i = 0 ; i < 1000; i++) { if (i == 200) { thread.join(); // 插队 main线程阻塞 } System.out.println("main" + i); } } }
守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如:后台记录操作日志、监控内存,垃圾回收等待…
在某个线程中运行的代码创建一个新的
Thread
对象时,新线程的优先级最初设置为等于创建线程的优先级,并且当且仅当创建线程是守护进程时才是守护线程。当Java虚拟机启动时,通常有一个非守护进程线程(通常调用某些指定类的名为
main
的方法)。 Java虚拟机将继续执行线程,直到发生以下任一情况:
- 已经调用了
Runtime
类的exit
方法,并且安全管理器已经允许进行退出操作。- 所有不是守护进程线程的线程都已经死亡,无论是从调用返回到
run
方法还是抛出超出run
方法的run
。
setDaemon
public final void setDaemon(boolean on)
将此线程标记为daemon线程或用户线程。当运行的唯一线程都是守护进程线程时,Java虚拟机将退出。
线程启动前必须调用此方法。
参数
on
- 如果true
,将此线程标记为守护线程异常
IllegalThreadStateException
- 如果这个线程是 alive
SecurityException
- 如果checkAccess()
确定当前线程不能修改此线程
线程同步
- 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制
synchronized
,当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待,多个线程操作同一个资源
使用后释放锁即可.存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下,加锁﹐释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题.
并发
同一个对象被多个线程同时操作。
不安全的案例
// 看一个小demo 不安全的买票
public class UnsafaBuyTicket {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"用户1").start;
new Thread(buyTicket,"用户2").start;
new Thread(buyTicket,"用户3").start;
}
class BuyTicket implements Runnable {
// 票数
private int ticketNums = 10;
// 外部停止的方式
boolean flag = true;
@Override
public void run() {
while (flag) {
buy();
}
}
public void buy() {
// 判断是否有票
if(ticketNums <= 0) {
return;
}
// 模拟延时
Thread.sleep(100);
// 买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums --);
}
}
// 不安全的取钱 两个人同时去银行取钱
public class UnsafeBank {
public static void main(String[] args) {
// 账户
Account account = new Account(100,"存折");
Drawing user1 = new Drawing(account,50,"用户1");
Drawing user2 = new Drawing(account,100,"用户2");
user1.start();
user2.start();
}
}
// 账户
class Account {
int money;
String name;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
// 银行:模拟取款
class Drawing extends Thread {
Account account; //账户
// 取了多少钱
int drawingMoney;
// 现在手里有多少钱
int nowMoney;
public Drawing (Account account,int drawingMoney , String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
// 取钱
@Override
public void run() {
// 判断有没有足够的钱
if (account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + "钱不够");
return;
}
// sleep 放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 卡内余额 = 余额 - 取得钱
account.money = account.money - drawingMoney;
// 手中的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为:" + account.money);
// Thread.currentThread().getName() = this.getName();
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
// 线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
list.add(Thread.currentThread().getName());
}).start;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
同步方法
由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法︰synchronized方法和synchronized 块.
同步方法:publicsynchronizedvoid method(int args)
synchronized方法控制对“对象”的访问﹐每个对象对应一把锁﹐每个synchronized方法都必须获得调用该方法的对象的锁才能执行﹐否则线程会阻塞,方法一旦执行﹐就独占该锁,直到该方法返回才释放锁﹐后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个大的方法申明为synchronized将会影响效率
同步块
synchronized
- 同步块:synchronized (Obj ){}
- Obj称之为同步监视器
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器﹐因为同步方法的同步监视器就是this ,就是这个对象本身,或者是class
- 同步监视器的执行过程
- 第一个线程访问,锁定同步监视器﹐执行其中代码.
- 第二个线程访问,发现同步监视器被锁定﹐无法访问.
- 第一个线程访问完毕,解锁同步监视器.
- 第二个线程访问,发现同步监视器没有锁﹐然后锁定并访问
Lock(锁)
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m() {
lock.lock();
try{
// 保证线程安全的代码;
} finally{
lock.unlock();
// 如果同步代码有异常,要将unlock()写入finally语句块
}
}
}
synchronized与Lock的对比
- Lock是显式锁((手动开启和关闭锁,别忘记关闭锁) synichronized是隐式锁,出了作用域自动释放
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序:
- Lock >同步代码块(已经进入了方法体,分配了相应资源) > 同步方法(在方法体之外)
线程通信
- 应用场景∶生产者和消费者问题
- 假设仓库中只能存放一件产品﹐生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费.
- 如果仓库中没有产品,则生产者将产品放入仓库﹐否则停止生产并等待,直到仓库中的产品被消费者取走为止.
- 如果仓库中放有产品﹐则消费者可以将产品取走消费﹐否则停止消费并等待,直到仓库中再次放入产品为止.
- 分析
- 这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件.
- 对于生产者,没有生产产品之前,要通知消费者等待﹒而生产了产品之后﹐又需要马上通知消费者消费
- 对于消费者﹐在消费之后﹐要通知生产者已经结束消费,需要生产新的产品以供消费.
- 在生产者消费者问题中,仅有synchronized是不够的
- synchronized可阻止并发更新同一个共享资源,实现了同步
- synchronized 不能用来实现不同线程之间的消息传递(通信)
解决方式一:管程法
// 测试:生产者消费者模型 --> 利用缓冲区解决:管程法
// 生产者 , 消费者, 产品, 缓冲区
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
// 生产者
class Productor extends Thread {
SynContainer synContainer;
public productor(SynContainer synContainer) {
this.synContainer = synContainer;
}
// 生产
@Override
public void run() {
for (int i = 0; i<100; i++) {
synContainer.push(new Chicken(i));
System.out.println("生产了"+i+“件产品”);
}
}
}
// 消费者
class Consumer extends Thread {
SynContainer synContainer;
public productor(SynContainer synContainer) {
this.synContainer = synContainer;
}
// 消费
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费类--->"+ synContainer.pop.id + "件产品");
}
}
}
// 产品
class Chicken {
}
// 缓冲区
class SynContainer {
// 需要一个容器大小
Chicken[] chickens = new Chicken[10];
// 容器计数器
int count = 0;
// 生产者放入产品
public synchronized void(Chicken chicken) {
// 如果容器满了,就需要等待消费者消费
if(count == chickens.length) {
// 通知消费者消费,生产者等待
}
// 如果没有满,我们就需要丢入产品
chickens[counts] = chicken;
counts ++;
// 可以通知消费者消费了
this.notifyAll();
}
// 消费者消费产品
public synchronized Chicken pop() {
// 判断能否消费
if(count == 0) {
// 等待生产者生产,消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果可以消费
count --;
Chicken chicken = chickensp[count];
// 消费完了,通知生产者生产
this.notifyAll();
return chicken;
}
}
解决方式二:信号灯法
// 测试生产者消费者问题2:信号灯法,标志位解决
public class TestPc2 {
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
// 生产者 ---> 演员
class Player extends Thread {
TV tv;
public player(TV tv) {
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i<20; i++) {
if (i%2 == 0){
this.tv.play("快乐大本营播放中");
} else {
this.tv.play("抖音:记录美好生活")
}
}
}
}
// 消费者 ---> 观众
class Watcher extends Thread {
TV tv;
public player(TV tv) {
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i<20; i++) {
tv.watch();
}
}
}
// 产品 ---> 节目
class TV {
// 演员表演,观众等待
// 观众观看,演员等待
String voice; // 表演的节目
boolean flag = true;
// 表演
public synchronized void play(String voice) {
if(!flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了:" + voice);
// 通知观众观看
this.notifyAll();//通知唤醒
this.voice = voice;
this.flag = !this.flag;
}
// 观看
public synchronized void watch() {
if(flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了:" + voice);
// 通知演员表演
this.notifyAll();
this.flag = !this.flag;
}
}
使用线程池
- 背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程池,对性能影响很大。
- 思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。
- 好处:
- 提高响应速度(减少了创建新线程的时间)
- 减低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间会终止
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads)
创建一个线程池,该线程池重用固定数量的从共享无界队列中运行的线程。 在任何时候,最多
nThreads
线程将处于主动处理任务。 如果所有线程处于活动状态时都会提交其他任务,则它们将等待队列中直到线程可用。 如果任何线程由于在关闭之前的执行期间发生故障而终止,则如果需要执行后续任务,则新线程将占用它。 池中的线程将存在,直到它明确地为shutdown
。
参数
nThreads
- 池中的线程数结果
新创建的线程池
异常
IllegalArgumentException
- 如果是nThreads <= 0
-
public class TestPool { public static void main(String[] args) { // 1、创建服务,创建线程池 // newFixedThreadPool 参数为线程池大侠 ExecutorService servie = Executors.newFixedThreadPool(10); // 执行 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); // 关闭连接 service.shutdown(); } } class MyThread implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()+i); } }