闭关修炼（一）多线程

最新推荐文章于 2021-08-25 20:18:35 发布
最新推荐文章于 2021-08-25 20:18:35 发布
阅读量182 收藏
点赞数
分类专栏： java闭关修炼
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19841133/article/details/112060551
版权

2021年，记得元旦快了乐~~

文章目录

线程与进程的区别

  • 什么是应用程序？
    可以执行的软件，在一个应用程序中，都会有一个进程。

  • 在进程中，程序代码如何执行？
    在进程中，一定有一个主线程，java中的main

  • 什么是线程？
    进程中的一条执行顺序/流程/路径。

  • 什么是进程？
    进程中有多个不同的执行路径，进程是线程的集合，是正在执行中的程序，任务管理器中可以看见进程。

  • 使用多线程的好处？
    提高程序效率。
    线程之间互不影响，因为线程都在自己独立运行。
    一个进程可中有多个线程，提高程序效率，提高用户体验。

  • 注意事项
    多线程并不提高单路径执行速度，而是多路径同时进行提高程序效率。

多线程应用场景

  1. 多线程下载
  2. 爬虫
  3. ajax异步上传
  4. 分布式job，同一时刻执行多个任务调度
  5. mq

继承方式创建多线程

创建线程有5种方式

  1. 继承Thread类
  2. runnable接口
  3. 使用匿名内部类方式
  4. callable
  5. 线程池

继承Thread接口，重写（override）run方法，run方法就是线程需要执行的代码。

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i =0 ; i< 30; i++){
            System.out.println(i);
        }
    }
}

启动线程，实例化类，调用start方法，如果调用run方法还是单独的执行run方法。

public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i =31 ; i< 60; i++){
            System.out.println("main" + i);
        }
    }

启动多线程，代码不会从上往下执行。

同步和异步的概念？

同步

main函数中有方法①和方法②，每个方法都需要花费10秒时间，则需要20秒完成main函数。

代码从上往下执行，被称为同步。

同步中，main函数的方法之间存在依赖关系，存在执行顺序，方法②等待方法①执行完毕后才能执行。

也叫做单线程。

异步

可以理解为多线程，方法①和方法②同时执行，每个方法都需要花费10秒时间，则需要10秒完成main函数。提高程序效率，线程间独立，互不影响。

CPU调度时 异步中有执行权的概念，但在宏观上看是同时进行的。

runnable接口创建多线程

创建类，实现runnable接口，重写run方法

class MyThread2 implements Runnable{
    public void run() {
        for (int i =0 ; i< 30; i++){
            System.out.println("run" + i);
        }
    }
}

启动线程方式，接口作为参数传递给Thread类，调用start方法

 public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        Thread thread = new Thread(myThread2);
        thread.start();
    }

使用继承方式创建线程还是使用runnable接口创建线程好？
使用接口方式，开发面向接口编程，继承后不能再继承，接口可以。

使用匿名内部类方式创建多线程

什么是匿名内部类？
没有名称的内部类。

例子：

abstract class Person{
    abstract void add();
}

 public static void main(String[] args) {
        Person person = new Person() {
            void add() {
                System.out.println("hello");
            }
        };
        person.add();
    }

线程中也是类似，实例化Thread类，runnable接口使用匿名内部类进行实现

	public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                System.out.println("Hello~");
            }
        });

        thread.start();
    }

Callable方式创建多线程

待更

线程池方式创建多线程

待更

多线程常见API

getId()

获取线程的id，id唯一

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i =0 ; i< 30; i++){
            System.out.println(getId()+ "run" + i);
        }
    }
}

主线程id如何获取？

System.out.println(Thread.currentThread().getId());

主线程id为1

任何一个程序都会有一个主线程，本质也是一个线程。

getName()

获取线程名称

System.out.println(Thread.currentThread().getName());

主线程的name是main
子线程名称默认是Thread-0，Thread-1，Thread-2…

sleep()

暂停

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i =0 ; i< 30; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getId()+ "run" + i);
        }
    }
}

Thread.currentThread()

获取当前线程，在用Runnable接口的时候需要用这种方式获取当前线程。

stop()

不安全，已过时

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i =0 ; i< 30; i++){
            if (i==5){
                stop();
            }
            System.out.println(getId()+ "run" + i);
        }
    }
}

Thread()

new Thread(new Runnable() {
            public void run() {
                System.out.println(1);
            }
        }, "线程名");

守护线程与非守护线程

什么是守护线程？
和main函数相关。
守护线程和主线程一起销毁。
如gc线程，垃圾回收机制中的单独的一个线程，专门用来回收垃圾，主线程结束，守护线程一起结束。

什么是非守护线程？
与main函数互不影响。
自己创建线程叫做用户线程，如果主线程停止了，不会影响用户线程，用户线程也叫非守护线程。

非守护线程演示代码：

	public static void main(String[] args) {
        new Thread(new Runnable() {
            @lombok.SneakyThrows
            public void run() {
                for (int i = 0; i <= 30; i++) {
                    Thread.sleep(300);
                    System.out.println(i);
                }
            }
        }, "线程名").start();

        System.out.println("主线程执行完毕");
    }

执行结果：在这里插入图片描述
主线程结束和非守护线程没有依赖关系。

设置守护线程

thread.setDaemon(true);

让守护线程和主线程一起销毁。

	public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @SneakyThrows
            public void run() {
                for (int i = 1000; i <= 3000; i++) {
                    System.out.println(i);
                }
            }
        }, "线程名");
        thread.setDaemon(true);
        thread.start();
        for (int i = 0; i <500; i++){
            System.out.println(i);
        }
        System.out.println("主线程执行完毕");
    }

多线程运行状态

在这里插入图片描述

  1. 新建状态
    new Thread

  2. 就绪状态
    就绪状态，等待cpu调度

  3. 运行状态
    获取cpu调度权

  4. 死亡状态
    run方法执行完毕，或者stop方法

  5. 休眠（阻塞）状态
    调用了sleep方法或者wait()方法，运行状态转到阻塞状态，再到就绪状态

join()方法作用

现有线程A和线程B，线程A调用了线程B的join方法，A等待B线程执行完毕之后再继续执行。也就是说线程A在调用B的join方法后，释放了执行权，让B先执行。

主线程让子线程先执行，方法：在主函数中调用子线程的join方法，例子如下：

	@SneakyThrows
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @SneakyThrows
            public void run() {
                for (int i = 1000; i <= 1500; i++) {
                    System.out.println(i);
                }
                System.out.println("子线程执行完毕！");
            }
        });
        thread1.start();
        thread1.join();
        for (int i = 0; i <= 50; i++) {
            System.out.println(i);
        }
    }

面试题顺序执行T1,T2,T3

现有T1,T2,T3三个线程，怎么保证T2在T1执行完后执行，T3在T2执行完后执行？

	@SneakyThrows
    public static void main(String[] args) {

        final Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i <= 10; i++) {
                    System.out.println(i);
                }
                System.out.println("子线程1执行完毕！");
            }
        });
        final Thread thread2 = new Thread(new Runnable() {
            @SneakyThrows
            public void run() {
                thread1.join();
                for (int i = 11; i <= 20; i++) {
                    System.out.println(i);
                }
                System.out.println("子线程2执行完毕！");
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @SneakyThrows
            public void run() {
                thread2.join();
                for (int i = 21; i <= 30; i++) {
                    System.out.println(i);
                }
                System.out.println("子线程3执行完毕！");
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
       
    }

案例多线程分批处理数据

端口扫描

	public void threadScanPort() {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        portCount.set(0);
        int totalThreadNum = 100;
        for (int n = 0; n <= totalThreadNum; n++) {
            executorService.execute(new ScanHandler(n, totalThreadNum));
        }
    }
    

	class ScanHandler implements Runnable {

        //用于端口扫描的总共线程数
        private int totalThreadNum;
        // 线程号
        private int threadNo;
        
        
        public ScanHandler(int threadNo, int totalThreadNum) {
            this.totalThreadNum = totalThreadNum;
            this.threadNo = threadNo;
        }

        @Override
        public void run() {
            int startPort = Integer.parseInt(startPortField.getText());
            int endPort = Integer.parseInt(endPortField.getText());
            String host = targetIp.getText();
            //startPort和endPort为成员变量，表示需要扫描的起止端口
            for (int port = startPort + threadNo; port <= endPort; port = port + totalThreadNum) {
                try {
                    Socket socket = new Socket();
                    socket.connect(new InetSocketAddress(host, port), 200);
                    socket.close();
                    String msg = "端口 " + port + " is open\n";
                    Platform.runLater(() -> {
                        taDisplay.appendText(msg);
                    });
                } catch (IOException e) {
                    System.out.println(port + "is close");
                }
                portCount.incrementAndGet();//扫描的端口数+1
            }

            if (portCount.get() == (endPort - startPort + 1)) {
                portCount.incrementAndGet();//加1，使得不再输出下面的线程扫描结束的信息
                Platform.runLater(() -> {
                    taDisplay.appendText("\n----------------多线程扫描结束--------------------\n");
                });
            }
        }
    }
likeGhee
关注
专栏目录
ORBSLAM源码理论分析3—tracking线程的追踪
yys2324826380的博客
04-01 811
ORBSLAM源码理论分析3—tracking线程的追踪1.创建帧32.跟踪前一帧1.特征匹配2.特征再匹配第一种情况第二种情况3.位姿优化3.跟踪局部地图1.匹配局部地图2.优化F3的位姿4.检查是否插入关键帧5.更新mvpMapPoints6.其它相关参数更新 1.创建帧3   与构造初始化帧2步骤完全相同，只不过提取的特征点数量减少为帧2的一半。帧3的关键点记为mvKeys3，帧3就是当前的...
32岁的我裸辞了，八年Java老鸟，只因薪水被应届生倒挂，在闭关三个月后拿到阿里Offer，定级P7
欢迎来到我的博客
01-11 521
今年32岁，我从公司离职了，是裸辞。 前段时间，我有一件事情一直憋在心里很难受，想了很久也没找到合适的人倾诉，就借着今天写出来。 我一个十几年开发经验，八年Java经验的职场老人，我慢慢涨上来的工资竟然被一个应届生倒挂了！ 当我得知这个消息的时候，我的心是拔凉拔凉的。 我现在只有一个想法，我想跳槽！ 可是，我现在已经32岁了，这让我一度陷入了纠结与迷茫。 应届生倒挂老员工 作为一个在公司待了六年的老员工，我一直兢兢业业，为了公司的项目能够按期上线，每天熬夜，加班加点。除了自己的本职工作外，
JAVA基础编程2
climbs的专栏
09-27 151
join线程等待 Vector<Thread> threads = new Vector<>(); for (int i = 0; i < 150 ; i++) { Thread thread = new Thread(new Runnable() { @Override public void run() { }); threads.add(th
php的ts和nts选择
bernin的博客
08-05 2049
  关于php的ts和nts ，你了解多少?   1. 简介     ts(Thread-Safety)：即线程安全，多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他 线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染php以ISAPI方 式加载的时候选择这个版本，php以ISAPI方式加载的时候选择这个版本。       n...
Windows下的PHP开发环境搭建——PHP线程安全与非线程安全、Apache版本选择，及详解五种运行模式。...
weixin_33966095的博客
11-05 297
今天为在Windows下建立PHP开发环境，在考虑下载何种PHP版本时，遭遇一些让我困惑的情况，为了解决这些困惑，不出意料地牵扯出更多让我困惑的问题。 为了将这些困惑一网打尽，我花了一下午加一晚上的时间查阅了大量资料，并做了一番实验后，终于把这些困惑全都搞得清清楚楚了。 说实话，之所以花了这么多时间，很大程度上是由于网上的资料几乎全都是支离破碎、以讹传讹的。既然我已经搞懂了，就花时间整理出来，...
apache cgi过多 php_扯点儿高性能（一）：CGI篇【搞附近】
weixin_39915210的博客
11-28 125
首先得说明下CGI和高性能没有半毛钱关系，甚至是低性能的代名词。其次是文中如果出现错误，微信公众号里发消息。最后是我觉得我这个公众订阅号的名字起的不好，至少不如原来那个服务号的名字好。原来那个服务号的名字叫做【可能是东半球最高端的API社区】，他的精髓就在于最前面的【可能是】三个字上。现如今，我给新公众号起名的时候明显就是给自己挖坑了，给公众号本身以及本人都带来了极高的风险：【高性能AP...
闭关修炼（十二） NIO
qq_19841133的博客
01-11 286
文章目录NIO什么是NIO缓冲区什么是缓冲区？ByteBuffer-HeapByteBuffer类源码解析ByteBuffer例子mark和resetmark例子直接缓冲区和非直接缓冲区哪一种缓冲区更为安全？简易病毒制作IO 缓冲区通道什么是NIO通道？Channel例子 NIO 什么是NIO New IO的简写。 NIO是一个可以替代标准java IO API的IO API(JKD1.4)，在IO基础之上进行改进，最大改进在NIO有一个非阻塞的IO，面向缓冲区的，原来的IO是阻塞的，面向流的。 NIO效
春招闭关修炼计划表1
08-08
春招闭关修炼计划是为求职者在春季招聘季前进行自我提升的一个详尽的学习计划，主要针对互联网大厂如百度、阿里、腾讯、字节跳动等以及TMD公司（今日头条、美团、滴滴）的软件开发岗位。这个计划涵盖了前端开发、...
老师讲的真棒！这一次带你搞懂SpringBoot核心原理，王者笔记！
m0_56835488的博客
04-16 266
前言 在本篇文章开始前，我想想来回答一个问题：我为什么要写这一篇关于面试的文章？ 原因有三：第一，我想为每一个为梦想时刻准备着的”有心人“尽一份自己的力量，提供一份高度精华的Java面试清单；第二，目前市面上的面试题不是答案不准确就是内容覆盖太窄，所以提供一份经典而又准确的面试题是非常有必要的；第三，本文会对部分提供详细解读和代码案例，让大家知其然并知其所然，从而学到更多的知识。 或许这份面试题还不足以概括所有Java问题，但有了它，我相信你一定不会”败“的很惨，因为有哦了它，足以应对目前市面上绝大部分的J
宅家30天，吃透这份测试工程师面试700道题解析，成功定级阿里P7
PZB924265的博客
08-25 4090
宅家里一个月，“闭关修炼”的你是不是正在为金九银十跳槽季发愁呢？小编今天说的这富含的15个互联网大厂测试工程师核心面试700题解析整理！内容包括： 软件测试基础210道面试题及答案解析 Linux54道面试题及答案解析 MySQL80道面试题及答案解析 web测试10道面试题及答案解析 接口测试35道面试题及答案解析 APP测试12道面试题及答案解析 Python106道面试题及大难解析 selenium40道面试题及答案解析 性能测试8道题面试题及答案解析 LordRunner80道面
java中等待一些线程执行完之后，再去执行别的方法（后者需要使用前者返回的结果）
虫逗蚊子的博客
03-20 5974
一、使用Thread的join()等待所有的子线程执行完毕，主线程在执行，thread.join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。/** * * 处理一个业务逻辑的场景：当一组线程都执行完之后，在执行别的线程（后者要使用前者返回的结果） * @au...
java vector 线程安全_java vector的多线程安全是否有用
weixin_39766910的博客
02-13 591
在网上搜了不少文章，发现有不少没讲清楚的，也有不少好文，本文希望更易懂地描述该问题。如有不对的地方，请多多指正~~vector的使用主要有如下两种场景：(1)vector所谓的多线程安全，只是针对单纯地调用某个方法它是有同步机制的。如add，多个线程都在对同一个容器add元素，vector能够保证最后总数是正确的，而ArrayList没有同步机制，就无法保证。(2)vector的多线程安全，在组合...
Java Vector线程安全？
zlp1992的专栏
12-30 1万+
Java Vector在多线程下是否是线程安全的
java Vector 在多线程使用中需要注意的问题
shecanwin的专栏
04-27 5030
众所周知，Java中有一些被称为是线程安全的集合容器，但是这里的线程安全会让人误以为在多线程环境中去使用这些容器就可以放心使用，包打天下。但是事实上并不是如此，在多线程中使用这些类仍然会存在问题。这就让人迷茫了，明明是线程安全的，为什么还会出错呢。我的理解是，明明是线程安全的，但是这些集合并不一定能在多线程环境中不出问题。 先看一段测试代码：public class VectorTest { pri
vector 和 ArrayList
swingseagull的专栏
05-21 1183
英文原文：http://www.javaworld.com/javaworld/javaqa/2001-06/03-qa-0622-vector.html采用Vector还是ArrayList,应该考虑以下4个因素：Synchronization Vector是Synchronized, 它的所有方法都是thread safe的。ArrayList是unsynchronized。所以，如果带抹布需
Java集合之Vector详解
热门推荐
Stay Hungry, Stay Foolish
06-12 1万+
简介Vector的内部实现类似于ArrayList，Vector也是基于一个容量能够动态增长的数组来实现的，该类是JDK1.0版本添加的类，它的很多实现方法都加入了同步语句，因此是线程安全的（但Vector其实也只是相对安全，有些时候还是要加入同步语句来保证线程的安全，我们后面会有例子来说明这一点）。Vector类声明如下：public class Vector&lt;E&gt; extends ...
java vector的多线程安全是否有用
weixin_34259559的博客
07-11 239
在网上搜了不少文章，发现有不少没讲清楚的，也有不少好文，本文希望更易懂地描述该问题。如有不对的地方，请多多指正~~ vector的使用主要有如下两种场景：（1）vector所谓的多线程安全，只是针对单纯地调用某个方法它是有同步机制的。如add，多个线程都在对同一个容器add元素，vector能够保证最后总数是正确的，而ArrayList没...
Java中Vector的操作一定是线程安全的嘛？
Oeljeklaus的博客
03-15 5793
Java中Vector的操作一定是线程安全的嘛？ Java中Vector类是JDK1.2加入的遗留集合，其内部的方法主要是通过synchronized关键字进行封装，保证这个类是一个线程安全的类，那么是不是vector的操作一定是线程安全的呢？本文将带你分析不一样的vector。 01 vector简介 首先，我们使用简单的描述vector的重要方法。这里是...
Java高级开发面试，跨越速运java面试经历
m0_57472099的博客
07-06 548
简介 基于SpringCloud(Hoxton.SR1) + SpringBoot(2.2.4.RELEASE) 的 SaaS型微服务脚手架，具备用户管理、资源权限管理、网关统一鉴权、Xss防跨站攻击、自动代码生成、多存储系统、分布式事务、分布式定时任务等多个模块，支持多业务系统并行开发， 支持多服务并行开发，可以作为后端服务的开发脚手架。代码简洁，架构清晰，非常适合学习使用。核心技术采用Nacos、Fegin、Ribbon、Zuul、Hystrix、JWT Toke
闭关decimal、
最新发布
07-27
decimal是Python中的一个模块，提供了精确的十进制运算功能。它可以用于处理涉及金融、货币、精确计算等需要保留小数位数的计算。你可以使用decimal模块来执行高精度的浮点数运算，避免了常规浮点数运算中可能出现的精度丢失问题。 在Python中使用decimal模块，你需要首先导入该模块，然后创建一个Decimal对象来表示你想要进行精确计算的数值。下面是一个简单的示例代码： ```python import decimal # 创建Decimal对象 a = decimal.Decimal('0.1') b = decimal.Decimal('0.2') # 进行加法运算 c = a + b # 打印结果 print(c) # 输出: 0.3 ``` 在这个示例中，我们使用Decimal对象来表示0.1和0.2这两个数值，并进行了加法运算。由于decimal模块提供了精确的十进制运算，所以得到的结果是正确的0.3。 除了加法运算，decimal模块还提供了其他常见的数学运算方法，如减法、乘法、除法等。你可以根据具体的需求使用这些方法来进行精确计算。 希望这个回答能够帮到你！如果你还有其他问题，请继续提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值