2021.10.18 每日学习打卡

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量120 收藏
点赞数
分类专栏： 打卡学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimorHasug/article/details/120844176
版权

线程方法

  1. 更改线程优先级 setPriority（int newPriority）

  2. 指定的毫米数内让当前执行的线程休眠（static void sleep（long millis））

  3. 等待该线程终止（void join（））

  4. 暂停当前正在执行的线程对象，并执行其他线程 static void yield（）

  5. 中断线程（勿用，容易搞出事）

  6. 测试线程是否处于活动状态

停止线程的方法

一般使用标志flag，让线程自己停止

package com.wang.Thread.state;
//测试停止线程
​
//1.利用次数，让线程正常停止
//2.利用标志位
//3.不要使用stop或destroy等JDK不建议使用的方法
public class TestStop implements Runnable{
​
    private boolean flag = true;
    @Override
    public void run(){
        int i = 0;
        while (flag){
            System.out.println("Run Thread"+i++);
        }
    }
​
    //设置一个公开的方法停止线程（转换标志位）
    public void stop(){
        this.flag = false;
    }
​
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==500){
                testStop.stop();
                System.out.println("线程停止了");
            }
        }
    }
}
​
​

线程的休眠

  • sleep制定当前线程的阻塞毫秒数

  • sleep存在异常interruptedException

  • sleep时间到达后线程进入就绪状态

  • sleep可以模拟网络延时，倒计时等

  • 每一个对象都有一把锁，sleep不会释放锁

package com.wang.Thread.state;
​
import java.text.SimpleDateFormat;
import java.util.Date;
​
//模拟倒计时
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;;
        }
    }
}
​

线程的礼让

  • 让当前正在执行的线程暂停，但不阻塞

  • 将线程从运行转为就绪

  • 让CPU重新调度，礼让不一定成功，看CPU“心情”

package com.wang.Thread.state;
​
​
//测试礼让线程，礼让不一定成功
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()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread()+"线程停止执行");
    }
}

线程强制执行

  • Join合并线程，待此线程完成后，再执行其他线程，其他线程阻塞

  • 插队

package com.wang.Thread.state;
//测试join方法，想象为插队
public class TestJoin implements Runnable{
​
​
    @Override
    public void run() {
        //测试使用时一定要循环次数大，才比较明显
        for (int i = 0; i < 10000; i++) {
            System.out.println("插队的来了"+i);
​
        }
    }
​
    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
         TestJoin testJoin = new TestJoin();
        Thread thread1 = new Thread(testJoin);
        thread1.start();
        for (int i = 0; i < 1000; i++) {
            if(i==200){
                thread1.join();
            }
            System.out.println("main"+i);
        }
​
​
​
    }
}
​
​
​

线程状态观测

  1. NEW

  2. RUNNABLE

  3. BLOCKED

  4. WAITTING

  5. TIMED_WAITING

  6. TERMINATED

package com.wang.Thread.state;
//观察测试线程的状态
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("OOOOOOOO");
        });
        
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//new
​
        //观察启动后
        thread.start();
        System.out.println(state);//run
        //只要线程不终止，就一直输出状态
        while(state!=Thread.State.TERMINATED){
            Thread.sleep(10);
            state = thread.getState();
            System.out.println(state);
        }
        //死亡之后的线程无法再次启动
    }
}
​

  • 线程死亡后就不能再次启动

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

  • 优先级用数字表示1-5-10

  • getPriority() setPriority()

package com.wang.Thread.state;
//测试线程的优先级
public class TestPriority {
​
    public static void main(String[] args) {
        MyPriority myPriority = new MyPriority();
​
        Thread t1 = new Thread(myPriority);
        Thread t0 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        t0.setPriority(2);
        t0.start();
        t1.start();
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        t3.setPriority(8);
        t3.start();
        t4.setPriority(Thread.NORM_PRIORITY);
        t4.start();
        t5.setPriority(Thread.MAX_PRIORITY);
        t5.start();
​
        //主线程优先级
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
    }
​
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
    }
}

优先级高的是可以先跑，但是不一定先运行，只是概率高，还是看CPU的调度

守护线程daemon

  • 线程分为用户线程和守护线程

  • 虚拟机必须确保用户线程执行完毕

  • 虚拟机不用等待守护线程执行完毕

  • 如：后台记录操作日志，监控内存，垃圾回收等

package com.wang.Thread.state;
//测试守护线程
//god bless u
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
​
        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程
        thread.start();
        new Thread(you).start();
    }
}
​
​
class You implements Runnable{
​
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("一生开心的活着");
        }
        System.out.println("goodbye world");
    }
}
​
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}
​
​

线程同步 *

多个线程操作同一个对象(并发发生时) 秒杀机制 宏观上并行，微观上并发

需要访问该对象的线程进入该对象的对象等待池排队

  • 锁机制(synchronized)

    • 一个线程持有锁会导致其他线程挂起

    • 多线程竞争，会额外的消耗系统资源

    • 优先级高的等待优先级低的，导致优先级倒置，性能问题

不安全的案例:

package com.wang.Thread.syn;
//不安全的买票
public class UnsafeBuyTicket {
​
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"dd").start();
        new Thread(buyTicket,"ss").start();
        new Thread(buyTicket,"aa").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--);
    }
}

同步方法

synchronized关键字机制

  • synchronize方法控制对this对象（默认对象）的访问

  • 每个对象都有一把锁

  • 每个synchronize方法都要拿到这个锁才能执行

  • 结束时释放该锁

同步方法锁的太多，浪费资源

package com.wang.Thread.syn;
//安全的买票
public class UnsafeBuyTicket {
​
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"dd").start();
        new Thread(buyTicket,"ss").start();
        new Thread(buyTicket,"aa").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();
            }
        }
    }
//变成同步方法,锁的是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"买到了"+ticketNums--);
    }
}

同步块

  • synchronized（Obj）{}

    • 称为同步监视器

    • Obj可以是任何对象，但是推荐使用共享资源做Obj

    • 锁的是实际改变的对象

    • {}内为要锁住对象之后，才能进行的操作

package com.wang.Thread.syn;
​
import com.wang.OOP.A;
//安全，使用了synchronized
// 同步块
public class UnsafeBank {
​
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"买房钱");
        Drawing woman = new Drawing(account,100,"女方");
        Drawing man = new Drawing(account,50,"男方");
        man.start();
       woman.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){
        this.account = account;
        this.drawingMoney = drawingMoney;
        this.nowMoney = nowMoney;
    }
​
    public void run(){
        synchronized (account){
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"没这么多钱");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money - drawingMoney;
            nowMoney = nowMoney + drawingMoney;
            System.out.println("余额为"+account.money);
            System.out.println(this.getName()+"手里有"+nowMoney);
        }
        }
​
}

JUC 的CopyOnWriteArrayList

package com.wang.Thread.syn;
​
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全类型的集合
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());
            });
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}
​

死锁

package com.wang.Thread;
//死锁
//等待对方释放资源
public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(1,"wang");
        Makeup girl2 = new Makeup(0,"li");
        girl1.start();
        girl2.start();
    }
​
}
​
class  LipStick{
​
}
​
class Mirror{
​
}
​
class Makeup extends Thread{
​
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();
​
    int choice;
    String girlName;
    @Override
    public void run() {
        makeup();
    }
​
     Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }
    private void makeup(){
        if(choice==0){
            synchronized (lipStick){
                System.out.println(this.girlName+"拿到口红");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
​
​
            } synchronized (mirror){
                System.out.println(this.girlName+"拿到镜子");
            }
        }
        else{
            synchronized (mirror){
                System.out.println(this.girlName+"拿到镜子");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
​
​
            }  synchronized (lipStick){
                System.out.println(this.girlName+"拿到口红");
            }
        }
        }
​
    }
​

Lock(ReentrantLock)

和synchronized一模一样

  • ReentrantLock类实现了Lock，常用

  • 用于同步问题中加锁

  • Lock锁性能更好

生产者消费者问题

synchronized不能用来实现不同线程之间的消息传递

  1. 缓冲区解决方式

  2. 信号灯法

线程通信

  1. wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁

  2. wait(long timeout) 指定等待的毫秒数

  3. notify() 唤醒一个处于等待状态的线程

  4. notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

均是Object类的方法，都只能在同步方法或同步代码块中使用

package com.wang.Advanced;
​
import java.awt.*;
​
//测试生产者消费者模型
//利用缓冲区，管程法
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++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(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;
            this.notifyAll();
        }
        //放入产品
        chickens[count] = chicken;
        count++;
        //通知消费
​
    }
​
​
    //消费者取出产品
​
    public synchronized Chicken pop(){
        if(count==0){
            //等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();
        return chicken;
​
    }
}

信号灯法

缓存为1的管程法

线程池

提升性能

思路：提前创建许多线程放入线程池，使用时获取，用完放回，避免频繁销毁创建

  • 提升响应速度-----减少创建线程的时间

  • 降低资源消耗-----重复利用池中的线程

  • 便于线程管理

    • corePoolSize 核心池的大小

    • maximumPoolSize 最大线程数

    • keepAliveTime 线程没有任务时最多保持多长时间后停止

package com.wang.Advanced;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool参数为大小
        ExecutorService service = Executors.newFixedThreadPool(10);
​
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
​
        //2.关闭连接
        service.shutdown();
    }
​
}
​
class MyThread implements Runnable{
    @Override
    public void run() {
​
            System.out.println(Thread.currentThread().getName());
        
    }
}
​

总结线程的三种创建方法

package com.wang.Advanced;
​
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
​
//回顾线程的创建
public class ThreadSummary {
    public static void main(String[] args) {
        new MyThread1().start();
​
        new Thread(new MyThread2()).start();
​
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();
        try {
            Integer integer = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
​
​
//1.继承Thread类
​
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MY THREAD1");
    }
}
//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MY THREAD2");
    }
}
​
//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("MY THREAD3");
        return 100;
    }
}
东东冲冲冲
关注
专栏目录
每日打卡2021.10.17
TimorHasug的博客
10-18 145
多线程 线程简介 Process 和 Thread（进程和线程） 进程包含多个线程 即使自己没有创建线程，后台也会有多个线程，如主线程，GC线程（Garbage Collection） 线程是CPU调度和执行的基本单位 main（）称之为主线程，为系统的入口，用于执行整个程序 线程的运行和调度器安排调度，调度器是与os紧密相关的，先后顺序不能人为干预 模拟多线程（单核但是切换快，感觉像是同时运行） 真正的多线程（多核）
每日学习打卡-汇总处
大林程序员
04-03 3366
无，就是一个打卡而已
auto.js B0037 每日答题代码 2021-10-24
weixin_33595571的博客
10-24 386
toast("每日答题") var question = "" var Title = "" function GetQuestion(){ sleep(1000) // className("android.view.View").text("查看提示").findOne().click(); // sleep(1000) widget = className("android.view.View").find(); log(widget.length) .
考研进度记录表（2021.6-2021.11）
沉鱼叶的博客
05-30 1652
考研进度记录表
2021入职一年教师述职报告.docx
11-17
9. 自我提升与敬业精神：教师提到OA办公系统的使用，以及每日的微笑打卡，体现其敬业精神和自我提升的决心，为学生树立了良好的榜样。 10. 学生状态的追踪与反馈：教师与任课老师保持沟通，了解学生的学习状态变化...
2021最新手账系列-一面一题B5.pdf
05-04
10. 学习辅助：在学习时记录要点、整理复习资料，利用手账提高学习效率。 考虑到给定文件的【标签】仅标为“手账”，可以推断，文件标题“2021最新手账系列-一面一题B5.pdf”可能是指一份以日历或规划表为模板，...
2021最新手账系列-12款功能页.pdf
05-04
7. 习惯打卡页：用于培养和记录个人习惯，如早睡早起、喝水、运动等，通过每日打卡来监督习惯的养成。 8. 月计划、周计划、日计划：这是手账中最常见的规划工具，帮助用户从月度、周度、日度三个不同的时间维度来...
(2021年整理)关于公司全面推行“钉钉”软件的通知.pdf
03-11
为确保审批流程的及时性，各部门负责人需每日（包括节假日）在晚上10点前检查审批信息。非工作时间发出的申请，可以使用DING功能提醒审批人。此外，各负责人需在周例会上对全体员工进行“钉钉”软件的培训和学习，...
2020-2021学年一年级中秋国庆假期指导手册.pdf
02-04
- **打卡制度**：家长需要每天在群里上传孩子完成作业的照片，记录孩子的进步。 #### 四、具体练习内容示例 - **练习一**： - 描写“1”的正确写法。 - 圈出特定数量的动物。 - 涂色练习。 - 生活语文复习：...
Java-网络
最新发布
2301_81543552的博客
09-14 481
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 515
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 611
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
C++位图的实现与详解
2301_80468112的博客
09-09 669
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 859
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
C#基础（11）函数重载
a6s686的博客
09-12 849
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 297
【代码】Spring AMQP给消息添加头信息。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 876
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 312
spirng security中的几大组件的差异和执行顺序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值