2021-07-20

最新推荐文章于 2024-10-20 17:09:42 发布
最新推荐文章于 2024-10-20 17:09:42 发布
阅读量76 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JiangHuFengZi/article/details/118943711
版权

初识并发问题

//多个线程同时操作同一个对象
//买火车票的例子

//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class Demo04 implements Runnable{
    //票数
    private int tickeNums = 10;
    @Override
    public void run() {
        while (tickeNums>0){
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--->拿到了第"+tickeNums--+"张票");
            /*
            小航--->拿到了第10张票
            小明--->拿到了第8张票
            小伟--->拿到了第9张票
            小伟--->拿到了第7张票
            小明--->拿到了第6张票
            小航--->拿到了第5张票
            小伟--->拿到了第4张票
            小明--->拿到了第4张票
            小航--->拿到了第3张票
            小伟--->拿到了第1张票
            小航--->拿到了第2张票
            小明--->拿到了第2张票
             */
        }
    }
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        new Thread(demo04,"小明").start();
        new Thread(demo04,"小航").start();
        new Thread(demo04,"小伟").start();
    }
}

案例：龟兔赛跑

  1. 首先来个赛道举例，然后要离终点越来越近
  2. 判断比赛是否结束
  3. 打印出胜利者
  4. 龟兔赛跑开始
  5. 故事中是乌龟赢得，兔子需要睡觉，所以我们模拟兔子睡觉
  6. 乌龟赢得比赛
//模拟龟兔赛跑
public class Race implements Runnable{
    //胜利者
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {

            //模拟兔子休息
            if ("兔子".equals(Thread.currentThread().getName())&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛结束
            boolean over = gameOver(i);
            //如果比赛结束
            if (over==true){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){//已经存在胜利者了
            return true;
        }else {
            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();
    }
}

线程创建方式三

实现Callable接口(了解即可)

  1. 实现Callable接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
  5. 提交执行任务：Future result1 = ser.submit(t1);
  6. 获取结果：boolean r1 = result1.get()
  7. 关闭服务：ser.shutdownNow();
public class Demo05 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("Callable执行了--->"+i+"次");
        }
        return true;
    }

    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        ExecutorService ser = Executors.newFixedThreadPool(1);
        Future<Boolean> s = ser.submit(demo05);
        try {
            Boolean b1 = s.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行了--->"+i+"次");
        }
        ser.shutdownNow();

    }
}

静态代理模式

//静态代理模式实现：婚庆公司案例
//静态代理模式总结：
/*
1.真实对象和代理对象，都要实现同一个接口。
2.代理对象要代理真实角色
 */
//好处：
    //代理对象可以做很多真实对象做不了的事情
    //真实对象可以专注做自己的事情
public class StacticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany();//new 一个婚庆公司的负责人
        You you = new You("江湖烽子");//真实的江湖烽子
        weddingCompany.setYou(you);//将他介绍给婚庆公司的负责人
        weddingCompany.HappyMarry();//婚庆公司帮他结婚
        /*
       结果：
        帮着操办结婚事项！
        江湖烽子结婚了，很开心！
        办完事收钱！
         */
    }
}

interface Marry{
    void HappyMarry();
}

//真实对象
class You implements Marry{
    private String name;

    public You(String name){
        this.name= name;
    }
    @Override
    public void HappyMarry() {
        System.out.println(name+"结婚了，很开心！");
    }
}

//代理对象（婚庆公司）
class WeddingCompany implements Marry{
    //代理谁？-->真实目标角色
    private Marry you;

    //1.可以通过构造器传参（真实角色）
//    public WeddingCompany(Marry you){
//        this.you = you;
//    }
    //2.也可以用set方法传参（真实角色）
    public void setYou(Marry you){
        this.you = you;
    }

    @Override
    public void HappyMarry() {
        before();
        you.HappyMarry();//you是真实结婚对象
        after();
    }

    private void before(){
        System.out.println("帮着操办结婚事项！");
    }

    private void after(){
        System.out.println("办完事收钱！");
    }
}

总结

new Thread(()->System.out.println("实现Runnable接口")).start();
//线程实现方式二，实现Runnable接口的底层就是代理模式，Thread和自定义的线程类都继承了Runnable接口，让Thread类来代理自定义的线程类来实现strat()方法，开启线程。

new WeddingCompany(new You("江湖烽子")).HappyMarry()

Lambda表达式

  • 避免匿名内部类定义过多

  • 其实质属于函数式编程的概念

    • (params) - > expression [表达式]
      • (params) - > statement [语句]
        • (params) - >{statements}

  • a - > System.out.println(“i like lamda—>” + a);

  • new Thread(() - >System.out.println(“多线程学习。。。”)).start();

函数式接口

  • 理解Functional Interface （函数式接口）是学习lambda表达式的关键所在。

  • 函数式接口的定义：

    • 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口。
    • 在这里插入图片描述

  • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

推导：

//推导Lambda表达式
public class TestLambda {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like Lambda2!");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();//接口对象
        like.lambda();

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like Lambda3!");
            }
        }

        like = new Like3();
        like.lambda();

        //5.匿名内部类:没有类的名称，必须借助接口或父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda4!");
            }
        };
        like.lambda();

        //6.用Lambda简化
        like = ()->{System.out.println("I like Lambda5!");};
        like.lambda();

    }
}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like Lambda1!");
    }
}

线程状态

五大状态

在这里插入图片描述

  • new ：Thread t = new Thread()：线程对象一旦创建就进入到了新生状态
  • 就绪状态：当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行。
  • 运行状态：当CPU调度时，进入运行状态，线程才真正执行线程体的代码块。
  • 阻塞状态：当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待CPU调度执行。
  • dead：线程中断或者结束，一旦进入死亡状态，就不能再次启动。

线程方法

  • setPriority(int newPriority)：更改线程的优先级。
  • static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠
  • void join()：（插队）等待该线程终止，在执行其它线程
  • static void yield()：暂停当前正在执行的线程对象，并执行其他线程
  • void interrupt()：中断线程，（别用这个方试）
  • boolean isAlive()：测试线程是否处于活动状态

停止线程

  1. 建议线程正常停止—>利用次数，不建议死循环
  2. 建议使用标志位---->设置一个标志位
  3. 不要使用stop或者destroy等过时或者jdk不建议使用的方法
//停止线程
//1.建议线程正常停止--->利用次数，不建议死循环
//2.建议使用标志位---->设置一个标志位
//3.不要使用stop或者destroy等过时或者jdk不建议使用的方法

public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("线程正在运行" + i++);
        }
    }
    //设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop stop = new TestStop();
        new Thread(stop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                //调用stop方法就可以停止线程
                stop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠

  • sleep（时间）指定当前线程阻塞的毫秒数；
  • sleep存在异常InterrupteException;
  • sleep时间达到后线程进入就绪状态；
  • sleep可以模拟网络延时，倒计时等。
  • 每一个对象都有一个锁，sleep不会释放锁；
//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) {
        //打印当前系统时间
        Date date = new Date();
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
                date = new Date();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public static void tenDown(){
        int num = 10;
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转换为就绪状态
  • 让CPU重新调度，礼让不一定成功！看CPU心情
//测试礼让线程
//礼让不一定成功，看cpu心情
public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"A线程").start();
        new Thread(myYield,"B线程").start();
        /*(礼让成功)
            A线程线程开始执行
            B线程线程开始执行
            A线程线程停止执行
            B线程线程停止执行
         */
    }
}

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 < 1000; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) {
        //启动线程
        TestJoin join = new TestJoin();
        Thread thread = new Thread(join);
        thread.start();
        //主线程
        for (int i = 0; i < 200; i++) {
            System.out.println("main===>"+i);
            if (i==50){
                try {
                    thread.join();//插队
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

测试线程状态

//观察测试线程状态
public class TestState {
    public static void main(String[] args) {
        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){//只要线程不终止，就一直输出状态
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();//更新线程状态
            System.out.println(state);
        }
    }
}

线程优先级

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

  • 线程的优先级用数字表示，范围从1~10，

    • Thread.MIN_PRIORITY = 1;
    • Thread.MAX_PRIORITY = 10;
    • Thread.NORM_PRIORITY = 5;

  • 使用以下方式改变获取优先级

    • getPriority() setPriority(int xxx)

  • 优先级低只是意味着获取调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。

注意点：优先级的设定要在start()调度之前

//测试线程的优先级
public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread threadC = new Thread(myPriority, "C线程");
        Thread threadA = new Thread(myPriority, "A线程");
        Thread threadB = new Thread(myPriority, "B线程");
        //先设置优先级,在启动
        threadA.setPriority(8);
        threadA.start();
        threadB.start();
        threadC.setPriority(4);
        threadC.start();
    }
}


class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}
//测试线程的优先级
public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread threadC = new Thread(myPriority, "C线程");
        Thread threadA = new Thread(myPriority, "A线程");
        Thread threadB = new Thread(myPriority, "B线程");
        //先设置优先级,在启动
        threadA.setPriority(8);
        threadA.start();
        threadB.start();
        threadC.setPriority(4);
        threadC.start();
    }
}


class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护(daemon)线程

  • 线程分为用户线程和守护线程。
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如，后台记录操作日志，监控内存，垃圾回收等待…
//测试守护线程
//上帝守护你
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You0 you0 = new You0();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程

        thread.start();
        new Thread(you0).start();//用户线程启动
        /*
        虚拟机只要保证用户线程执行完毕后，就会关闭，同时守护线程也会关闭
         */
    }
}

//上帝
class God implements Runnable{
    //没有给他设置停止条件
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}

//你
class You0 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生开心的活着");
        }
        System.out.println("goodbye world");
    }
}
JiangHuFengZi
关注
2021-07-28
lixiaoxianer的博客
07-28 4109
kubeadmin 安装k8s1.20集群 标签（空格分隔）： kubernetes架构系列 一：k8s1.20.x 的重要更新 二：k8s1.20.x 的安装 2.1 ：高可用Kubernetes集群规划 2.2 yum 的更新配置 （所有节点全部安装） 一：k8s1.20.x 的重要更新 1、Kubectl debug 设置一个临时容器 2、Sidecar 3、Volume：更改目录权限，fsGroup 4、ConfigMap和Secret K8S官网：https://kubernetes.io/
2021-07-16
热门推荐
qq_52895917的博客
07-16 2万+
import io import sys import urllib.request as req import bs4 import re import PIL.Image import time import random from PIL import Image import urllib import os import requests from fake_useragent import UserAgent from multiprocessing import Pool import mu
2021-07-20 M1版本mac Parallel16.5.1安装kali Parallel Tools
Sp4rkW的博客
07-20 2059
2021-07-20 M1版本mac Parallel16.5.1安装kali Parallel Tools
2021-01-10
qq_22667507的博客
01-10 1038
jupyter notebook中直接安装python的第三方库。 例如安装pymysql ： ! pip install pymysql。 升级pip：
网络攻防｜CVE-2021-42287、CVE-2021-42278域内提权
weixin_42282189的博客
12-20 2675
作者： r0n1n 免责声明：本文仅供学习研究，严禁从事非法活动，任何后果由使用者本人负责。 0x01 漏洞原理 Microsoft Windows Active Directory 域服务权限提升漏洞（CVE-2021-42278、CVE-2021-42287）攻击者可利用该漏洞将域内的普通用户权限提升到域管理员权限，造成风险和危害极大。 漏洞情报来源： 1、影响版本 CVE-2021-42278 ￮ Windows Server 2012 R2 ￮ Windows Server 2012 (S.
2021-01-07
qq_42497621的博客
01-07 2万+
开发中遇到的问题： Data truncated for column ‘user_id’ at row 1 解决方法是看数据库与java类中的属性是否一致，我的在数据库中id的属性设置成了int型，java类中的id是String型导致了不匹配。
2021-07-14
unix2linux的博客
07-14 2495
cat /etc/redhat-release CentOS Linux release 8.2.2004 (Core) wget https://mirrors.tuna.tsinghua.edu.cn/apache/hive/hive-3.1.2/apache-hive-3.1.2-bin.tar.gz --no-check-certificate wget https://mirrors.tuna.tsinghua.edu.cn/apache/hadoop/common/hadoop-2.10
2021-03-07
scqq1的专栏
03-07 1404
centos 8 pip install aiohttp multidict/_multidict.c:1:10: 致命错误：Python.h：没有那个文件或目录 #include "Python.h" ^~~~~~~~~~ 编译中断。 error: command 'gcc' failed with exit status 1 ---------------------------------------- Command ...
WordPress BuddyPress 越权漏洞RCE（CVE-2021-21389）
Biu_Biu_Bi的博客
07-15 1175
BuddyPress 是一个用于构建社区站点的开源 WordPress 插件。在 7.2.1 之前的 5.0.0 版本的 BuddyPress 中，非特权普通用户可以通过利用 REST API 成员端点中的问题来获得管理员权限。该漏洞已在 BuddyPress 7.2.1 中修复。插件的现有安装应更新到此版本以缓解问题。
log-aggregated-2021-07-20-080015.ips
07-20
log-aggregated-2021-07-20-080015.ips
2号楼结构施工图-2021-07-20.dwg
11-04
2号楼结构施工图-2021-07-20.dwg
CoppeliaSim_Moveit-2021-07-20_16.43.41.mp4
07-21
CoppeliaSim和Moveit的联合仿真
gtk3-runtime-3.24.29-2021-04-29-ts-win64.exe
07-10
gtk3-runtime-3.24.29-2021-04-29-ts-win64.exe
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 553
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
No provider available from registry RegistryDirectory
最新发布
小道仙的后宫
10-20 218
最近在做配置文件升级，服务比较多，之前的Dubbo配置各个服务写的比较乱，有的用Nacos上的 data-id，有的又是在自己的服务引入配置遂准备统一了，全部都用Nacos上的配置，同时修改了Dubbo服务名发到线上的时候，线上崩了，部分服务出现如下错误注： IP和服务名做了隐藏处理。
java 异常包装
fdvvg的博客
10-17 332
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 419
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
代理模式、BigDecimal详解
Mr.W的博客
10-14 1072
BigDecimal可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过BigDecimal来做的。浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断。想要解决浮点数运算精度丢失这个问题，可以直接使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可​​// 0。
time_str = "2021-07-20" 转换成时间戳
06-02
if (_str = "2021-07-20" # 将日期字符串转换成时间数组 time_array = time.strptime(date_str, "%cropList[i].id == id) { printf("作物种类编号：%d\n", cropList[i].id); printfY-%m-%d") # 将时间数组转换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值