JAVA多线程
核心概念
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程;
- main()称之为主线程,为系统入口,用于执行整个程序
- 在一个线程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为的干预的
- 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制;
- 线程会带来额外的开销,如CPU调度时间,并发控制开销;
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致;
三种创建方式
继承Tread类(重点)
public class TestThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("TestThread.run: "+i);
}
}
public static void main(String[] args) {
TestThread testThread = new TestThread();
//开启线程
testThread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("TestThread.main: "+i);
}
}
}
线程不一定立即执行,CPU安排调度
实现Runnable接口(重点)
public class TestThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("TestThread.run: "+i);
}
}
public static void main(String[] args) {
TestThread testThread = new TestThread();
//开启线程
new Thread(testThread).start();
for (int i = 0; i < 1000; i++) {
System.out.println("TestThread.main: "+i);
}
}
}
龟兔赛跑例子:
public class TestThread3 implements Runnable {
private String winner;
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
try {
Thread.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
boolean flag = check(i);
if (flag) {
break;
}
System.out.println(Thread.currentThread().getName() + "=====>跑了" + i + "步");
}
}
public boolean check(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(String[] args) {
TestThread3 testThread3 = new TestThread3();
new Thread(testThread3, "兔子").start();
new Thread(testThread3, "乌龟").start();
}
}
乌龟=====>跑了93步
乌龟=====>跑了94步
乌龟=====>跑了95步
乌龟=====>跑了96步
兔子=====>跑了1步
乌龟=====>跑了97步
乌龟=====>跑了98步
乌龟=====>跑了99步
兔子=====>跑了2步
winner is乌龟
实现Callable接口
图片下载器
public class TestCollable implements Callable<Boolean> {
private String url;
private String name;
public TestCollable(String url, String name) {
this.url = url;
this.name = name;
}
@Override
public Boolean call() {
WebDownloader2 webDownloader = new WebDownloader2();
webDownloader.downLoader(url, name);
System.out.println(name);
return false;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestCollable t1 = new TestCollable("http://nimg.ws.126.net/?url=http%3A%2F%2Fdingyue.ws.126.net%2F2021%2F0524%2F23d33360j00qtkixi0065c000qo0140c.jpg&thumbnail=650x2147483647&quality=80&type=jpg", "1.jpg");
TestCollable t2 = new TestCollable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Finews.gtimg.com%2Fnewsapp_match%2F0%2F12070081997%2F0.jpg&refer=http%3A%2F%2Finews.gtimg.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1627736036&t=6a487c9cfc9954360ca08a2b1a35c08b", "2.jpg");
TestCollable t3 = new TestCollable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Finews.gtimg.com%2Fnewsapp_match%2F0%2F6311385436%2F0.jpg&refer=http%3A%2F%2Finews.gtimg.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1627736036&t=db6580ea15875a49d9b9bdc115dd4d3e", "3.jpg");
TestCollable t4 = new TestCollable("http://p4.ssl.cdn.btime.com/t0107f73bda6cf546d0.jpg", "04.jpg");
ExecutorService ser = Executors.newFixedThreadPool(4);
Future<Boolean> r1 = ser.submit(t1);
Future<Boolean> r2 = ser.submit(t2);
Future<Boolean> r3 = ser.submit(t3);
Future<Boolean> r4 = ser.submit(t4);
boolean res1 = r1.get();
boolean res2 = r2.get();
boolean res3 = r3.get();
boolean res4 = r4.get();
System.out.println("res1 = " + res1);
System.out.println("res2 = " + res2);
System.out.println("res3 = " + res3);
System.out.println("res4 = " + res4);
ser.shutdownNow();
}
}
class WebDownloader2 {
public void downLoader(String url, String name) {
try {
FileUtils.copyURLToFile(new URL(url), new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常:downLoader ");
}
}
}
Lambda表达式
lambda表达式实现需要一个函数式接口
**函数式接口:**只有一个抽象方法的接口
//函数式接口
interface InterfaceFunction(){
abstract void a();
}
lambda表达式无参实现
public class B{
public static void main(String []arg){
InterfaceFunction interfaceFunction = null;
interfaceFunction = ()->{
System.out.println("我是lambda表达式!!!")
}
}
}
lambda表达式有参实现
public class B{
public static void main(String []arg){
InterfaceFunction interfaceFunction = null;
//方式一:
interfaceFunction = (a)->{
System.out.println("我是lambda表达式!!!");
}
//方式二:简化小括号
interfaceFunction = a->{
System.out.println("我是lambda表达式!!!");
}
//方式三:简化花括号
interfaceFunction = a -> System.out.println("我是lambda表达式!!!");
}
//总结:1、只有当lambda表达式里面只有一行代码时方可简化花括号
// 2、前提是函数式接口
// 3、当有多个参数时,不能省略小括号
}
//函数式接口
interface InterfaceFunction(){
abstract void a(int a);
}
线程的状态
线程方法
方法 | 说明 |
---|---|
setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
void join() | 等待该线程终止 |
static void yield() | 暂停当前正在执行的线程对象,并执行其他线程 |
void interrupt() | 中断线程,别用这个方式 |
boolean isAlive() | 测试线程是否处于活动状态 |
停止线程
- 不在推荐使用JDK提供的stop()、destroy()方法,这两个方法已经废弃
- 推荐线程自己停止下来
- 建议使用一个标志位(flag)进行线程终止
public class TestThread4 implements Runnable{
//标志位
private boolean flag = true;
@Override
public void run() {
while (flag){
System.out.println("TestThread4.run");
}
}
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestThread4 testThread4 = new TestThread4();
new Thread(testThread4).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main ===> i = " + i);
if (i==900){
testThread4.stop();
System.out.println("ruan线程已停止");
}
}
}
}
线程休眠
- sleep(时间)指定当前线程阻塞的毫秒数;
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时,倒计时等。
- 每一个对象都有一个锁,sleep不会释放锁;
线程礼让
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转为就绪状态
- 让CPU重新调度,礼让不一定成功!线程A礼让了线程B,但当CPU再次调度的时候,又调度A线程
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"A").start();
new Thread(myYield,"B").start();
}
}
class MyYield implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始");
Thread.yield();//线程礼让
System.out.println(Thread.currentThread().getName()+"线程结束");
}
}
join
- join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
- 可以想象成插队
public class TestJoin implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Vip线程===" + i);
}
}
public static void main(String[] args) throws InterruptedException {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
for (int i = 0; i < 30; i++) {
if (i == 10) {
thread.join();
}
System.out.println("TestJoin.main主线程 ===" + i);
}
}
}
观察线程状态
-
线程状态。线程可以处于以下状态之一:
NEW
尚未启动的线程处于此状态。RUNNABLE
在Java虚拟机中执行的线程处于此状态。BLOCKED
被阻塞等待监视器锁定的线程处于此状态。WAITING
正在等待另一个线程执行特定动作的线程处于此状态。TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。TERMINATED
已退出的线程处于此状态。
一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。
Thread thread = new Thread(()->{ for(int i=0;i<5;i++){ try{ thread.sleep(1000); }catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("=========="); }); Thread.State state = thread.getState(); Systemp.out.println("state1 ="+state); thread.start(); state = thread.getState(); System.out.println("state2 ="+state); while(state != Thread.State.TERMINATED){ thread.sleep(100); state = thread.getState(); System.out.println("state3 ="+state); } thread.start();//线程死亡后就不能再次开启线程,否则会报错java.lang.IllegalThreadStateException
}
state 1 = NEW
state 2 = RUNNABLE
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TERMINATED
``
线程优先级
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度那个线程来执行。
- 线程的优先级用数字表示,范围从1~10.
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
- 改变或获取优先级方式
- getPriority()
- setPriority(int xxx)
public class TestPriority {
public static void main(String[] args) {
//主线程
System.out.println(Thread.currentThread().getName()+"====:"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t0 = new Thread(myPriority);
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
t0.start();
//优先级的设置再开启线程之前设置
t3.setPriority(Thread.MAX_PRIORITY);
t3.start();
t1.setPriority(1);
t1.start();
t2.setPriority(4);
t2.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"====:"+Thread.currentThread().getPriority());
}
}
运行结果
注意:
- 优先级高的不一定先执行
- 优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用。这都是看CPU的调度心情
守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕,如后台记录操作日志,垃圾回收等待
只要当前JVM实例中尚存在任何一个非守护线程没有结束,守护线程就全部工作;只有当最后一个非守护线程结束时,守护线程随着JVM一同结束工作。
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
//setDaemon默认为false,即用户线程,为true为守护线程,设置须在开启线程之前
thread.setDaemon(true);
thread.start();
new Thread(you).start();
}
}
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("===我是守护线程===");
}
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("每天都活得很开心");
}
System.out.println("++++++goodBy world++++++");
}
}
}
线程同步
并发:同一个对象被多个线程同时操作
处理多线程问题时,多个线程访问同一个对象,并且某些对象还想要修改这个对象,这时候我们就需要线程同步,线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用
**形成条件:**队列+锁
由于同意进程的多个线程共享同一块存储空间,在带来方便的同时,也带来访问冲突的问题,为了保证数据在方法中被访问时的正确性,在访问时加入**锁机制** synchronized ,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可
存在问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换 和 调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题。
同步块
- 同步块:synchronized(Obj){ }
- Obj称之为同步监视器
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器(增删改查的对象)
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this就是这个对象本身,或者是class
- 同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行其中代码
- 第二个线程访问,发现同步监视器被锁定,无法访问
- 第一个线程访问完毕,解锁同步监视器
- 第二个线程访问,发现同步监视器没有锁,然后锁定并访问
同步方法——买票
public class UnsafeTickte {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"张三").start();
new Thread(station,"李四").start();
new Thread(station,"王五").start();
}
}
class BuyTicket implements Runnable {
private int ticketNums = 10;
private boolean flag = true;
@Override
public void run() {
while(flag){
try {
Buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private synchronized void Buy() throws InterruptedException {
if (ticketNums<=0){
flag = false;
return;
}
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
}
}
同步代码块——取钱
public class UnsafeMoney {
public static void main(String[] args) {
Account account = new Account(400, "公积金");
Drawing you = new Drawing(account, 50, "你");
Drawing wef = new Drawing(account, 100, "妻子");
you.start();
wef.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 drawMoney;
int nowMoney;
public Drawing(Account account, int drawMoney, String name) {
super(name);
this.account = account;
this.drawMoney = drawMoney;
}
@Override
public void run() {
synchronized (account){
if (account.money - drawMoney < 0) {
System.out.println(Thread.currentThread().getName() + "钱不够,取不了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.money = account.money - drawMoney;
nowMoney = nowMoney + drawMoney;
System.out.println(account.name+"余额为:" + account.money);
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
}
死锁
某一个同步代码块同时拥有“两个以上对象的锁”时,就可能会发生死锁
死锁避免方法
-
产生死锁的四个必要条件:
- 互斥条件:一个资源每次只能被有一个进程使用
- 请求与保持条件:一个进程因请求资源而阻塞时,对以获得资源保持不放
- 不剥夺条件:进程以获得的资源,在未使用完之前,不能强行剥夺
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
-
如何避免死锁:
- 只需破以上所列出的任意一个或多个条件就可以避免死锁发生
Lock(锁)
- JDK5开始,Java提供了显式定义同步锁对象实现同步。同步锁使用Lock对象充当
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
- **Reentrant Lock(可重入锁)**类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是Reentrant Lock,可以显式加锁,释放锁。
public class TestLock {
public static void main(String[] args) {
Locks locks = new Locks();
new Thread(locks).start();
new Thread(locks).start();
new Thread(locks).start();
}
}
class Locks implements Runnable {
private int tickets = 10;
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("tickets = " + tickets--);
} else {
break;
}
} finally {
lock.unlock();
}
}
}
}
synchronized与Lock的区别
- Lock是显式锁(手动开启和关闭锁)synchronized是隐式锁,出了作用域自动释放
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,jvm将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序
- Lock > 同步代码块(已经进入了方法体,分配了相应资源)> 同步方法(在方法体之外)
线程通信
synchronized可阻止并发更新同一个共享资源,实现同步;但不能用来实现不同线程之间的消息传递(通信)
Java提供了几个方法解决线程之间的通信问题
方法名 | 作用 |
---|---|
wait() | 表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁 |
wati(long timeout) | 指定等待的毫秒数 |
notify() | 唤醒一个处于等待状态的线程 |
notifyAll() | 唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先调度 |
注意:均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常
解决方式
一:管程法——生产者消费者模式
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new product(container).start();
new Constructor(container).start();
}
}
//产品 炸鸡
class Chicken {
int id;
public Chicken(int id) {
this.id = id;
}
}
//生产者
class product extends Thread {
SynContainer container;
public product(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
container.push(new Chicken(i));
System.out.println("生产了" + i + "炸鸡");
}
}
}
//消费者
class Constructor extends Thread {
SynContainer container;
public Constructor(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了" + container.pop().id + "炸鸡");
}
}
}
//缓冲区
class SynContainer {
Chicken[] chickens = new Chicken[10];
int count = 0;
//生产者生产产品
public synchronized void push(Chicken chicken) {
//如果容器满了,就需要等待消费
if (count == chickens.length) {
//通知消费者消费
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有满,就生产
chickens[count] = chicken;
count++;
//通知消费者消费
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop() {
if (count == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
Chicken chicken = chickens[count];
this.notifyAll();
return chicken;
}
}
二:信号灯法(标志位)——演员观众
public class TestTV{
public static void main(String[] args){
TV tv = new TV();
new Player(tv).start();
new Watch(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){
tv.play("《王爷到》");
}else{
tv.play("广告");
}
}
}
}
//观众
class Watch extends Thread{
TV tv;
public Watch(TV tv){
this.tv = tv;
}
@Override
public void run(){
for(int i=0;i<20;i++){
tv.see();
}
}
}
//节目
class TV{
//节目名
private String name;
//标志
private boolean flag = true;
//表演方法
public synchronized void play(String name){
if(!flag){
try{
this.wait();
}catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("表演了:"+name);
this.notifyAll();
this.name = name;
this.flag = !this.flag;
}
//观看方法
public synchronized void see(){
if(flag){
try{
this.wait();
}catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了:"+name);
this.notifyAll();
this.flag = !this.flag;
}
}
线程池
- 背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大
- **思路:**提前创建好多个线程,放入线程池中,使用时直接获取,使用完毕放回池中。可以避免频繁创建销毁、实现重复利用。类比共享单车
- 好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中的线程,不需要每次都创建)
- 便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后终止