多线程
目录
2.sleep存在异常InterruptedException
1.join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
同步方法:public synchronized void method(int args){}😊
缺陷:若将一个大的方法申明为synchronized将会影响效率
1.继承Thread类
package com.qyx.www.lesson12; public class TestThread1 extends Thread { @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在看代码--"+i); } } public static void main(String[] args) { //main线程 主线程 //创建一个线程对象 TestThread1 testThread1 = new TestThread1(); //调用start()方法开启线程 testThread1.start(); for (int i = 0; i < 200; i++) { System.out.println("我在学习多线程--"+i); } } }
2.网图下载
package com.qyx.www.lesson12; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; public class TestThread2 extends Thread { private String url;//网络图片地址 private String name;//保存的文件名 public TestThread2(String url,String name){ this.url = url; this.name = name; } @Override public void run() { WebDownloader webDownloader = new WebDownloader(); webDownloader.downloader(url,name); System.out.println("下载了文件名为:" +name); } public static void main(String[] args) { TestThread2 t1 = new TestThread2("http://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/1.jpg","1.jpg"); TestThread2 t2 = new TestThread2("http://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/2.jpg","2.jpg"); TestThread2 t3 = new TestThread2("http://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/3.jpg","3.jpg"); t1.start(); t2.start(); t3.start(); } } class WebDownloader{ //下载方法 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方法出现问题"); } } }
3.初识并发问题
package com.qyx.www.lesson12; public class TestThread4 implements Runnable{ private int ticketNums = 10; @Override public void run() { while (true){ if (ticketNums<=0){ break; } //模拟延时 try{ Thread.sleep(200); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票"); } } public static void main(String[] args) { TestThread4 ticket = new TestThread4(); new Thread(ticket,"小明").start(); new Thread(ticket,"老师").start(); new Thread(ticket,"黄牛").start(); } }
4.龟兔赛跑
package com.qyx.www.lesson12; //模拟龟兔赛跑 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(10); } catch (InterruptedException e) { e.printStackTrace(); } } //判断比赛是否结束 boolean flag = gameOver(i); //如果比赛结束了,就停止程序 if (flag){ break; } System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步"); } } //判断是否完成比赛 private boolean gameOver(int steps){ //判断是否有胜利者 if (winner!=null){//已经存在胜利者了 return true; }{ if (steps>=100){ winner = Thread.currentThread().getName(); System.out.println("winner is"+winner); return true; } } return false; } public static void main(String[] args) { Race race = new Race(); new Thread(race,"兔子").start(); new Thread(race,"乌龟").start(); } }
5.lamda表达式
6.线程休眠Sleep
1.sleep(时间)指定当前线程阻塞的毫秒数
2.sleep存在异常InterruptedException
3.sleep时间达到后线程进入就绪状态
4.sleep可以模拟网络延时,倒计时等
5.每个对象都有一个锁,sleep不会释放锁
package com.qyx.www.lesson12; import java.util.Date; import java.text.SimpleDateFormat; public class TestSleep2 { public static void main(String[] args) { //打印当前系统时间 Date startTime = new Date(System.currentTimeMillis());//获取当前时间 while (true){ try { Thread.sleep(1000); System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime)); startTime = new Date(System.currentTimeMillis()); } catch (InterruptedException e) { e.printStackTrace(); } } } //模拟倒计时 public static void tenDown() throws InterruptedException{ int num = 10; while (true){ Thread.sleep(1000); System.out.println(num--); if (num<=0){ break; } } } }
7.线程礼让 yield
1.礼让线程,让当前正在执行的线程暂停,但不阻塞
2.将线程从运行状态转为就绪状态
3.让cpu重新调度,礼让不一定成功,看cpu心情
package com.qyx.www.lesson12; 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()+"线程停止执行"); } }
8.线程强制执行 join
1.join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
2.可以想象成插队
package com.qyx.www.lesson12; public class TestJoin implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; 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 < 500; i++) { if(i == 200){ thread.join();//插队 } System.out.println("main" + i); } } }
9.观测线程状态
Thread.State
线程状态。线程可以处于以下状态之一:
1.NEW
尚未启动的线程处于此状态。
2.RUNNABLE
在java虚拟机中执行的线程处于此状态
3.BLOCKED
被阻塞等待监视器锁定的线程处于此状态
4.WAITING
正在等待另一个线程执行特定动作的线程处于此状态
5.TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
6.TERMINATED
已退出的线程处于此状态
一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态
package com.qyx.www.lesson12; public class TestState { public static void main(String[] args) throws InterruptedException { 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(); System.out.println(state); //NEW //观察启动后 thread.start();//启动线程 state = thread.getState(); System.out.println(state); //RUN while (state != Thread.State.TERMINATED){ //只要线程不终止,就一直输出状态 Thread.sleep(100); state = thread.getState();//更新线程状态 System.out.println(state);//输出状态 } } }
10.线程优先级 Priority
1.Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行
2.线程的优先级用数字表示,范围从1-10
(1)Thread.MIN_PRIORITY = 1;
(2)Thread.MAX_PRIORITY = 10;
(3)Thread.NORM_PRIORITY = 5;
3.使用以下方式改变或获取优先级
getPriority().setPriority(int xxx)
11.守护(daemo)线程
1.线程分为用户线程和守护线程
2.虚拟机必须确保用户线程执行完毕
3、虚拟机不用等待守护线程执行完毕
4.如 后台记录操作日志,监控内存,垃圾回收等待...
12.线程同步机制
并发:同一个对象被多个线程同时操作,相当于等待(排队)
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待使用后释放锁即可,存在以下问题:
(1)一个线程持有锁会导致其他所有需要此锁的线程挂起
(2)在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
(3)如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题
13.三大不安全案例
package com.qyx.www.lesson12; public class UnsafeBuyTicket { 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; boolean flag = true;//外部停止方式 @Override public void run() { //买票 while (flag){ try { buy(); }catch (InterruptedException e){ e.printStackTrace(); } } } private void buy() throws InterruptedException{ //判断是否有票 if (ticketNums<=0){ flag = false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--); } }
package com.qyx.www.lesson12; //不安全的取钱 //两个人去银行取钱,账户 public class UnsafeBank { public static void main(String[] args) { //账户 Account account = new Account(100,"结婚基金"); Drawing you = new Drawing(account,50,"你"); Drawing girlFriend = new Drawing(account,100,"girlFriend"); you.start(); girlFriend.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; } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 account.money = account.money - drawingMoney; //你手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name+"余额为:"+account.money); System.out.println(this.getName()+"手里的钱"+nowMoney); } }
package com.qyx.www.lesson12; import java.util.ArrayList; import java.util.List; //线程不安全的集合 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(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }
14.同步方法即同步块
(1)由于我们可以通过private关键字来保存数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块:
同步方法:public synchronized void method(int args){}😊
(2)synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个大的方法申明为synchronized将会影响效率
💖同步块
(1)同步块:synchronized(obj){}
(2)Obj称之为同步监视器
Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器,因为同步方法的同步监视器就说this,就是这个对象本身,或者是class
(3)同步监视器的执行过程
1.第一个线程访问,锁定同步监视器,执行其中代码
2.第二个线程访问,发现同步监视器被锁定,无法访问
3.第一个线程访问完毕,解锁同步监视器
4.第二个线程访问,发现同步监视器没有锁,然后锁定并访问
15.CopyOnWriteArrayList
package com.qyx.www.lesson12; import java.util.concurrent.CopyOnWriteArrayList; public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }
16.死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有"两个以上对象的锁"时,就可能会发生"死锁"的问题
死锁避免方法
产生死锁的四个必要条件
1.互斥条件:一个资源每次只能被一个进程使用
2.请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
3.不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
package com.qyx.www.lesson12; public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0,"灰姑凉"); Makeup g2 = new Makeup(1,"白雪公主"); g1.start(); g2.start(); } } //口红 class Lipstick{ } //镜子 class Mirror{ } class Makeup extends Thread { //需要的资源只有一份,用static来保证只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice; //选择 String girlName; //使用化妆品的人 Makeup(int choice, String girlName) { this.choice = choice; this.girlName = girlName; } @Override public void run() { //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆,互相持有对方的锁,就是需要拿到对方的资源 private void makeup() throws InterruptedException { if (choice == 0) { synchronized (lipstick) { //获得口红的锁 System.out.println(this.girlName + "获得口红的锁"); Thread.sleep(1000); } synchronized (mirror) { //一秒钟后想获得镜子 System.out.println(this.girlName + "获得镜子的锁"); } } else { synchronized (mirror) { //获得镜子的锁 System.out.println(this.girlName + "获得镜子的锁"); Thread.sleep(2000); } synchronized (lipstick) { //一秒钟后想获得口红 System.out.println(this.girlName + "获得口红的锁"); } } } }
17.Lock(锁)
1.从JDK5.0开始,java提供了更强大的线程同步机制---通过显式定义同步锁对象来实现同步.同步锁使用Lock对象充当
2.java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具.锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
3.ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁,释放锁
synchronized与lock的对比
1.lock是显式锁(手动开启和关闭锁,别忘记关闭锁)synchronized是隐式锁,出了作用域自动释放
2.lock只有代码块锁,synchronized有代码块锁和方法锁
3.使用lock锁,jvm将花费较少的时间来调度线程,性能更好.并且具有更好的扩展性 (提供更多的子类)
4.优先使用顺序:
lock>同步代码块(已经进入了方法体,分配了相应资源)>同步方法(在方法体之外)
package com.qyx.www.lesson12; import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2).start(); new Thread(testLock2).start(); new Thread(testLock2).start(); } } class TestLock2 implements Runnable{ int ticketNums = 10; //定义lock锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true){ try { lock.lock();//加锁 if (ticketNums > 0) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ticketNums--); }else { break; } }finally { //解锁 lock.unlock(); } } } }
18.管程法
package com.qyx.www.lesson12; import javax.swing.plaf.synth.SynthConstants; import java.util.concurrent.SynchronousQueue; //测试生产者消费者模型-》利用缓冲区解决:管程法 public class TestPC { public static void main(String[] args) { SynContainer container = new SynContainer(); new Productor(container).start(); new Consumer(container).start(); } } //生产者 class Productor extends Thread{ SynContainer container; public Productor(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 Consumer extends Thread{ SynContainer container; public Consumer(SynContainer container){ this.container = container; } @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("消费了-->"+container.pop().id+"只鸡"); } } } //产品 class Chicken{ int id; //产品编号 public Chicken(int id) { this.id = 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; } }
19信号灯法
package com.qyx.www.lesson12; 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 Watcher(TV tv) { this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { tv.watch(); } } } //产品-->节目 class TV { //演员表演,观众等待 T //观众观看,演员等待 F 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; } }
20.线程池
1.背景:经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大.
2.思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中.可以避免频繁创建销毁,实现重复利用.类似生活中的公共交通工具.
3.好处:
(1)提高响应速度(减少了创建新线程的时间)
(2)降低资源消耗(重复利用线程池中线程,不需要每次都创建)
(3)便于线程管理(.....)
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
使用线程池
1.JDK5.0起提供了线程池相关API:ExecutorService和Executors
2.ExecutorService:真正的线程池接口.常见子类ThreadPoolExecutor
(1)void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
(2)<T>Future<T>submit(Callable<T>task):执行任务,有返回值,一般用来执行Callable
(3)void shutdown():关闭连接池
3.Executors:工具类,线程池的工厂类,用于创建并返回不同类型的线程池