多线程2
多线程
在比如售票的代码中如下：
public class CellRunnable implements Runnable{
//这个票让三个线程共享
static int piao=1000; //共享数据
//确保这个锁对象，只有一个，多个线程共用一把锁
static Object obj=new Object();
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
synchronized (obj){
if (piao >= 1) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第：" + (piao--) + " 张票");
}
}
}
}
}
public class MyTest {
public static void main(String[] args) {
CellRunnable cellRunnable = new CellRunnable();
Thread th1 = new Thread(cellRunnable, "窗口1");
Thread th2 = new Thread(cellRunnable, "窗口2");
Thread th3= new Thread(cellRunnable, "窗口3");
th1.start();
th2.start();
th3.start();
我们写的这段售票代码，出现了线程安全问题。多线程的环境下，在对共享数据进行操作时，有可能会出现线程安全问题。出现安全问题的原因在于一下因素：
1.为多线程环境？
2.多个线程在共享数据？
3.多个语句在操作某个变量？
出现以上情况，我们会发生线程安全问题，所以要解决以上 问题，需要用到线程同步。
线程同步
若多个线程操作同一个资源，可能会出现线程不安全的情况。
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步实质上就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
由于同一个进程的多个线程共享同一块存储空间，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。
同步代码块：
synchronized (锁){放你认为有肯能出现问题的代码}
锁：你可以使用Java里面的任意一个对象，来充当锁,注意，多个线程要共享一把锁，才能锁住
public class CellRunnable implements Runnable {
//这个票让三个线程共享
static int piao = 100; //共享数据
//确保这个锁对象，只有一个，多个线程共用一把锁
static Object obj = new Object();
int i = 1;
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
//th1 th2 th3
if (i % 2 == 0) {
synchronized (this) { //或者synchronized (CellRunnable.class)
//当th1这个线程进来同步代码块后，就持有了这个锁，其他线程没有持有锁，那么就要处于等待状态，等在同步代码块的外面
if (piao >= 1) {
//模拟一下真实的售票环境，有网络延迟。
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第：" + (piao--) + " 张票");
}
}
} else {
maiPiao();
}
i++;
//th1 执行完了，出了同步代码块，就会释放锁。释放锁了之后，多个线程再去争抢CPU的时间片
}
}
//同步方法：我们可以把一个方法用synchronized这个关键字修饰，来封装一段代码，来解决线程安全问题
//同步方法：默认用的锁对象是this
public synchronized void maiPiao() {
//System.out.println(this);
if (piao >= 1) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第：" + (piao--) + " 张票");
}
}
}
或者
public class CellRunnable implements Runnable {
//这个票让三个线程共享
static int piao = 100; //共享数据
//确保这个锁对象，只有一个，多个线程共用一把锁
static Object obj = new Object();
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
//th1 th2 th3
maiPiao();
//th1 执行完了，出了同步代码块，就会释放锁。释放锁了之后，多个线程再去争抢CPU的时间片
}
}
// 同步方法的使用的是 this 这个锁对象
public synchronized void maiPiao() {
//当th1这个线程进来同步代码块后，就持有了这个锁，其他线程没有持有锁，那么就要处于等待状态，等在同步代码块的外面
if (piao >= 1) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第：" + (piao--) + " 张票");
}
}
}
lock（）：加锁
public class CellRunnable implements Runnable {
//这个票让三个线程共享
static int piao = 100; //共享数据
static ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
//th1 th2 th3
//加锁
lock.lock();
try {
if (piao >= 1) {
//模拟一下真实的售票环境，有网络延迟。
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第：" + (piao--) + " 张票");
}
}catch (Exception e){
e.printStackTrace();
}finally {
//释放锁 不管有没有遇到异常，锁必须释放
lock.unlock();
}
}
}
}
该机制会带来以下问题：
-
一个线程持有锁会导致其他所有需要此锁的线程挂起；
-
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
-
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。
线程死锁
概念：多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行。而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题
产生死锁的必要条件：- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系
解决死锁
上面列出的死锁的四个必要条件，只要想办法破坏其中的任意一个或多个条件，就可以避免死锁发生
假设有两个女生，在出门之前同时进行化妆（需要拿镜子和口红），若一个女生先拿到镜子，另一个女生先拿到口红，之后，为了得到彼此的口红和镜子，两方都需要等待。解决
public class DeadLocked { public static void main(String[] args) { Makeup g1 = new Makeup(0,"白雪公主"); Makeup g2 = new Makeup(1,"灰姑凉"); new Thread(g1).start(); new Thread(g2).start(); } } //化妆 class Makeup implements Runnable{ //选择 int choice; //谁进来了 String girlName; //两个对象 static LipStick lipStick = new LipStick(); static Mirror mirror = new Mirror(); public Makeup(int choice,String girlName){ this.choice = choice; this.girlName = girlName; } @Override public void run() { //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆的方法 public void makeup() throws InterruptedException { if (choice==0){ //先拿口红,再拿镜子 synchronized (lipStick){ System.out.println("拿到口红"); Thread.sleep(1000); //等待拿镜子的人释放锁 } synchronized (mirror){ System.out.println("拿到镜子"); } }else { //先拿镜子 , 再拿口红 synchronized (mirror){ System.out.println("拿到镜子"); Thread.sleep(2000); //等待拿口红的人释放锁 } synchronized (lipStick){ System.out.println("拿到口红"); } } } } //口红 class LipStick{ } //镜子 class Mirror{ }
Lock（锁）
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentranLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
public class TestLock {
public static void main(String[] args) {
HelloWorld helloWorld = new HelloWorld();
new Thread(helloWorld).start();
new Thread(helloWorld).start();
}
}
class HelloWorld implements Runnable{
int ticketNums = 100;
//可重入锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock(); //加锁
//判断是否有票
if (ticketNums>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
}else {
break;
}
} finally {
lock.unlock();//解锁
}
}
}
}
synchronized 与 Lock 的对比
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）
线程协作——生产者消费者模式
应用场景：生产者和消费者问题
- 假设仓库只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
- 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止
分析：这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
- 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
- 在生产者消费者问题中，仅有synchronized是不够的：
1.synchronized可阻止并发更新同一个共享资源，实现了同步
2.但synchronized不能用来实现不同线程之间的消息传递（通信）
线程方法：针对线程之间互相通信的问题，Java提供了几个方法用于解决
- wait()：表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
- wait(long timeout)：指定等待的毫秒数
- notify()：唤醒一个处于等待状态的线程
- notifyall()：唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
注意：以上的均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IllegaIMonitorStateException
解决方式：针对生产者/消费者模式的问题，有两种方法可以解决
管程法
-
生产者：负责生产数据的模块（可能是方法、对象、线程、进程）；
-
消费者：负责处理数据的模块（可能是方法、对象、线程、进程）；
-
缓冲区：消费者不能直接使用生产者的数据，它们之间有一个缓冲区
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
示例如下：//思路 //1.思考需要哪些对象? // 生产 , 消费 , 产品 , 容器 //2.分工 /* 生产者只管生产 消费者只管消费 鸡: 实体类 容器 : 容器添加数据. 要判断容器是否满 , 满了等待消费者消费 没有满,通知生产者生产 容器减少数据 判断还有没有数据, 没有数据的话 . 等待生产者生产 消费完毕 , 通知生产者生产 */
import java.sql.SQLOutput;
//测试生产者和消费者问题
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
}
//生产者
class Productor extends Thread{
//需要向容器中加入产品
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
@Override
public void run() {
for (int i = 1; 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 = 1; i < 100; i++) {
//消费者拿走产品
Chicken chicken = container.pop();
System.out.println("消费者消费了"+chicken.id+"鸡");
}
}
}
//缓冲区-->容器
class SynContainer{
//容器
Chicken[] chickens = new Chicken[10];
//容器的计数器
int num = 0;
//生产者放入产品
public synchronized void push(Chicken chicken) {
//假如容易已经满了,就不用放,等待消费者消费
if (num>=chickens.length){
//等待消费者消费
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//假如容器没有满 , 通知生产生成
System.out.println("num,,,,,"+num);
chickens[num] = chicken;
System.out.println("数组有多少个元素"+num);
num++;
//通知消费者消费
this.notifyAll();
}
//消费者拿走产品
public synchronized Chicken pop(){
//假如容器空的,等待
if (num<=0){
//等待生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num--;
Chicken chicken = chickens[num];
//通知生产者生产
this.notifyAll();
return chicken;
}
}
//产品->鸡
class Chicken {
int id;
public Chicken(int id) {
this.id = id;
}
信号灯法
在产品中设置一个标志位，利用标志位（flag）来选择让生产者执行逻辑还是让消费者执行逻辑（类似于红灯停，绿灯行）
示例如下：
//生产者消费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("节目:快乐大本营播放中");
System.out.println();
}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{
//演员说话 , 观众等待
//观众观看 , 演员等待
boolean flag = true;
//说话
String voice;
//表演
public synchronized void play(String voice){
//演员等待
if (!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("表演了"+voice);
this.voice = voice;
//让观众观看
this.notifyAll();
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：线程没有任务时最多保持多长时间后终止
使用线程池：JDK 5.0起提供了线程池相关API：ExecutorService和Executors - ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable - void shutdown()：关闭线程池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
示例：
public class ThreadPool{
public static void main(String[] args) {
//创建一个线程池(池子大小)
ExecutorService pool = Executors.newFixedThreadPool(10);
//执行runnable接口实现类
pool.execute(new MyThread4());
pool.execute(new MyThread4());
pool.execute(new MyThread4());
pool.execute(new MyThread4());
//关闭连接池
pool.shutdown();
}
}
class MyThread4 implements Runnable{
@Override
public void run() {
System.out.println("MyThread4");
}
}
Timer 定时器 一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。
Timer timer = new Timer();
//让定时器，执行定时任务
MyTimerTask myTimerTask = new MyTimerTask(timer);
//等3秒之后执行任务
// timer.schedule(myTimerTask,3000);
//等3秒第一次执行任务，以后间隔1秒重复执行定时任务
timer.schedule(myTimerTask, 3000,1000);
//取消定时任务
// myTimerTask.cancel();
//取消定时器
//timer.cancel();
}
}
class MyTimerTask extends TimerTask{
private Timer timer;
public MyTimerTask(Timer timer) {
this.timer = timer;
}
@Override
public void run() {
System.out.println("执行");
//取消定时器
// timer.cancel();
}
}
Timer timer = new Timer();
//在指定日期执行定时任务
MyTask task = new MyTask();
String dateStr="2020-06-07 09:48:00";
//在指定日期执行定时任务
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);
//在指定日期执行定时任务一次
// timer.schedule(task,date);
//在指定日期第一次执行任务，以后间隔1s重复执行
timer.schedule(task, date,1000);
}
}
class MyTask extends TimerTask{
@Override
public void run() {
System.out.println("定时任务执行了");
}
}
练习：定时删除一个文件夹
Timer timer = new Timer();
String dateStr = "2020-06-07 10:16:00";
//在指定日期执行定时任务
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);
MyTask myTask = new MyTask(timer);
timer.schedule(myTask,date);
}
}
class MyTask extends TimerTask{
private Timer timer;
public MyTask(Timer timer) {
this.timer = timer;
}
@Override
public void run() {
File folder = new File("C:\\Users\\ShenMouMou\\Desktop\\demo");
deleteFolder(folder);
//关闭定时器
timer.cancel();
System.out.println("删除完毕");
}
private void deleteFolder(File folder) {
File[] files = folder.listFiles();
for (File f : files) {
if (f.isFile()) {
f.delete();
}else{
deleteFolder(f);
}
}
folder.delete();
}
}