多线程

最新推荐文章于 2020-07-24 22:45:40 发布
最新推荐文章于 2020-07-24 22:45:40 发布
阅读量514 收藏 7
点赞数 5
分类专栏： 学习考研 文章标签： 多线程 java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42832437/article/details/106805009
版权
1. 并发与并行

并发:指两个或多个事件在同一个时间段内发生。
并行:指两个或多个事件在同一时刻发生(同时发生)。

在这里插入图片描述

2. 线程与进程

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个。
进程;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、
运行到消亡的过程。
线程:线程是进程中的一个执行单元,负责当前进程中程序的执行, -个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。
简而言之:一个程序运行后至少有一个进程 , 一个进程中可以包含多个线程
在这里插入图片描述
在这里插入图片描述
线程调度:
分时调度
所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间。
抢占式调度
优先让优先级高的线程使用CPU ,如果线程的优先级相同,那么会随机选择一个(线程随机性) , Java使用的为抢占式调度。

3. 创建线程类

Java使用java. lang. Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是
完成一定的任务,实际上就是执行一段程序流即一 段顺序执行的代码。 Java使用线程执行体来代表这段程序流。
Java中通过继承Thread类来创建并启动多线程的步骤如下:

  1. 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
  2. 创建Thread子类的实例,即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程

单线程

package cn.itcast.day12.demo02;

public class Person {
    private String name;
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(name + "-->" + i);
        }
    }
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

主函数

package cn.itcast.day12.demo02;
/*
主线程:执行主(main)方法的线程
单线程程序:java程序中只有一个线程
执行从main方法开始，从上到下依次执行


JVM执行main方法, main方法会进入到栈内存
JV会找操作系统开辟一条main方法通 向cpu的执行路径
cpu就可以通过这个路径来执行main方法
而这个路径有一个名字, 叫main(主)线程
 */
public class SoloThread {
    public static void main(String[] args) {
        Person pe = new Person("周冬雨");
        pe.run();

        Person pe1 = new Person("刘亦菲");
        pe1.run();

    }
}

执行结果

周冬雨-->0
周冬雨-->1
周冬雨-->2
周冬雨-->3
周冬雨-->4
周冬雨-->5
周冬雨-->6
周冬雨-->7
周冬雨-->8
周冬雨-->9
周冬雨-->10
周冬雨-->11
周冬雨-->12
周冬雨-->13
周冬雨-->14
周冬雨-->15
周冬雨-->16
周冬雨-->17
周冬雨-->18
周冬雨-->19
刘亦菲-->0
刘亦菲-->1
刘亦菲-->2
刘亦菲-->3
刘亦菲-->4
刘亦菲-->5
刘亦菲-->6
刘亦菲-->7
刘亦菲-->8
刘亦菲-->9
刘亦菲-->10
刘亦菲-->11
刘亦菲-->12
刘亦菲-->13
刘亦菲-->14
刘亦菲-->15
刘亦菲-->16
刘亦菲-->17
刘亦菲-->18
刘亦菲-->19
3.2 多线程的建立

创建多线程程序的第一种方式: 创建Thread类的子类
java. lang. Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类
实现步骤:

  1. 创建一个Thread类的子类
  2. 在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
  3. 创建Thread类的子类对象
  4. 调用Thread类中的方法start方法,开启新的线程,执行run方法

void start()使该线程开始执行; Java虚拟机调用该线程的run方法。
结果是两个线程并发地运行;当前线程(main线程)和另一个线程(创建的新线程，执行其run方法)。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度,那个线程的优先级高，那个线程优先执行;同-一个优先级,随机选择一个执行
多线程

package cn.itcast.day12.demo02;
//1. 创建一个Thread类的子类
public class MyThread extends Thread {

    //2. 在Thread类的子类中重写Thread类中的方法，设置线程任务（开启线程要做什么）
    @Override
    public void run(){
        for (int i = 0; i < 10; i++){
            System.out.println("run: " + i);
        }
    }
}

主函数

package cn.itcast.day12.demo02;



public class MulThread {
    public static void main(String[] args) {
        //3. 创建Thread类的子类对象
        MyThread mt = new MyThread();
        //4. 调用Thread类中的方法start,开启新的线程，执行run方法
        mt.start();

        for(int i = 0; i < 10; i++){
            System.out.println("main :" + i);
        }
    }
}

执行结果

run: 0
main :0
run: 1
main :1
run: 2
main :2
run: 3
main :3
run: 4
main :4
run: 5
main :5
run: 6
main :6
run: 7
run: 8
run: 9
main :7
main :8
main :9
3.3 多线程的原理

在这里插入图片描述
在这里插入图片描述

4. Thread类中常用的方法
4.1 获取线程名称

获取线程的名称:

  1. 使用Thread类中的方法getName()
    String getName() 返回该线程的名称。
  2. 可以先获取到当前正在执行的线程,使用线程中的方法getName( )获取线程的名称
    static Thread current Thread()返回对当前正在执行的线程对象的引用。
package cn.itcast.day12.demo02;
//定义一个Thread类的子类
public class MyThread01 extends Thread {
//重写Thread类中的run方法，设置线程任务
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}

主函数

package cn.itcast.day12.demo02;

public class GetThreadName {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread01 mt = new MyThread01();
        //调用start方法，开启新线程，执行run方法
        mt.start();

        new MyThread01().start();
        new MyThread01().start();

    }
}

执行结果

Thread-0
Thread-2
Thread-1
4.2 设置线程名称

设置线程的名称:(了解)

  1. 使用Thread类中的方法setName(名字)
    void setName(String name) 改变线程名称，使之与参数name相同。
  2. 创建一个带参数的构造方法 ,参数传递线程的名称;调用父类的带参构造方法，把线程名称传递给父类,让父类( Thread)给子线程起一个名字
    Thread(String name) 分配新的Thread 对象。
package cn.itcast.day12.demo02;

public class MyThread02 extends Thread{
    public MyThread02(){}
    public MyThread02(String name){
        super(name);
    }
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}

主函数

package cn.itcast.day12.demo02;

public class SetThreadName {
    public static void main(String[] args) {
        //开启多线程
        MyThread02 mt = new MyThread02();
        mt.setName("周冬雨");
        mt.start();

        //开启多线程
        new MyThread02("刘亦菲").start();
    }
}

执行结果

周冬雨
刘亦菲
4.3 sleep

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
毫秒数结束之后,线程继续执行

package cn.itcast.day12.demo02;

public class sleep {
    public static void main(String[] args) {
        //模拟毫秒
        for (int i = 0; i <= 60  ; i++) {
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠1秒钟
            try{
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
4.4 创建线程方式二

采用. java.lang.runnable ’ 也是非常常见的一-种,我们只需要重写run方法即可。
创建多线程程序的第二种方式:实现Runnable接口
java. lang. Runnable
Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法。
java. lang. Thread类的构造方法
Thread(Runnable target) 分配新的Thread 对象。
Thread(Runnable target, String name) 分配新的Thread 对象。
实现步骤:

  1. 创建一-个Runnabl e接口的实现类
  2. 在实现类中重写Runnable接口的run方法,设置线程任务
  3. 创建一个Runnable接口的实现类对象
  4. 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
package cn.itcast.day12.demo02;
//1. 创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    //2. 在实现类中重写Runnable接口的run方法。设置线程任务
    @Override
    public void run(){
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

主函数

package cn.itcast.day12.demo02;

public class Runnable01 {
    public static void main(String[] args) {
        //3. 创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        //5.调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

执行结果

Thread-0-->0
Thread-0-->1
main-->0
Thread-0-->2
main-->1
Thread-0-->3
main-->2
Thread-0-->4
Thread-0-->5
Thread-0-->6
Thread-0-->7
main-->3
Thread-0-->8
main-->4
Thread-0-->9
main-->5
main-->6
main-->7
main-->8
main-->9
main-->10
main-->11
main-->12
main-->13
main-->14
main-->15
main-->16
main-->17
main-->18
main-->19
4.4 Thread和Runnable的区别

实现Runnable接口创建多线程程序的好处:

  1. 避免了单继承的局限性
  • 一个类只能继承-个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
  • 实现了Runnable接口,还可以继承其他的类,实现其他的接口
  1. 增强了程序的扩展性,降低了程序的耦合性(解耦)
  • 实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
  • 实现类中，重写了run方法:用来设置线程任务
  • 创建Thread类对象,调用start方法:用来开启新线程
package cn.itcast.day12.demo02;
//1. 创建一个Runnable接口的实现类
public class RunnableImpl2 implements Runnable{
    //2. 在实现类中重写Runnable接口的run方法。设置线程任务
    @Override
    public void run(){
        for(int i = 0; i < 10; i++){
            System.out.println("Hello World" + i);
        }
    }
}

主函数

package cn.itcast.day12.demo02;

public class Runnable01 {
    public static void main(String[] args) {
        //3. 创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
      //  Thread t = new Thread(run);
        Thread t = new Thread(new RunnableImpl2());
        //5.调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

执行结果

Hello World0
Hello World1
Hello World2
Hello World3
Hello World4
Hello World5
Hello World6
Hello World7
Hello World8
Hello World9
main-->0
main-->1
main-->2
main-->3
main-->4
main-->5
main-->6
main-->7
main-->8
main-->9
5. 匿名内部类方式实现线程的创建

匿名内部类方式实现线程的创建
匿名:没有名字
内部类:写在其他类内部的类
匿名内部类作用:简化代码
把子类继承父类,重写父类的方法，创建子类对象合一步完成
把实现类实现类接口，重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字

格式:
new
父类/接口(){
重复父类/接口中的方法
};

package cn.itcast.day12.demo02;

public class InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread().start();
        new Thread(){
            //重写run方法，设置线程任务
            @Override
            public void run(){
                for (int i = 0; i <10 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"周冬雨");
                }
            }
        }.start();

        //Runnable r = new RunnableImpl();//多态
        Runnable r = new Runnable(){

            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"刘亦菲");
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){

            //重写run方法，设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"杨超越");
                }
            }
        }).start();
    }
}

执行结果

Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-2-->杨超越
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-0-->周冬雨
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
Thread-1-->刘亦菲
孤鸿末子
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
c++多线程
02-20
一个进程中可以同时运行多个线程，每个线程可以执行不同的任务，这就是所谓的多线程。同一进程中的多个线程将共享该进程中的全部系统资源，如虚拟地址空间、文件描述符和信号处理等，但是同一个进程中的多个线程都有...
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
Java多线程详解及示例
最新发布
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
数据库的查询操作
qq_42832437的博客
07-24 1748
1. 基础查询 1.语法: select 字段列表. from 表名列表. where 条件列表 group by 分组字段 having 分组之后的条件 order by 排序 limit 分页限定 基础查询 多个字段的查询 去除重复 计算列 起别名
序列化流
qq_42832437的博客
07-03 1469
1. 序列化与反序列化 把对象以流的方式，写入到文件中保存,叫写对象,也叫对象的序列化。 把文件中保存的对象,以流的方式读取出来，叫做读对象,也叫对象的反序列化 2. 对象的序列化流：ObjectOutputStream java. io. objectOutputStream extends OutputStream objectOutputStream :对象的序列化流 作用:把对象以流的方式写入到文件中保存 构造方法: objectOutputStream(OutputStream out) 创
数据库的CRUD操作
qq_42832437的博客
07-10 1081
1. MySQL通用语法 什么是SQL ? structured Query Language :结构化查询语言 其实就是定，义了操作所有关系型数据库的规则。每一种数据库操作的方式存在不一样的地方，称为“方言”。 SQL通用语法 SQL语句可以单行或多行书写,以分号结尾。 可使用空格和缩进来增强语句的可读性。 MySQL数据库的SQL 语句不区分大小写，关键字建议使用大写。 3种注释 单待注释: – 注释内容 或 # 注释内容(mysql特有) *多行注释: / * 注释 * / 2. SQL分类
异常
qq_42832437的博客
06-16 634
1. 异常的概念 异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响. 在程序中的意思就是: 异常:指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止。 在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个集常对象。Java处理异常的方式是中断处理。 异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行. 2. 异常的分类 异常机制其实是帮助我们找到程序中的问题
Map集合
qq_42832437的博客
06-10 610
1.Map集合概述 Collection中的集合,元素是孤立存在的(理解为单身) ,向集合中存储元素采用一个个元素的方式存储。 Map中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的 Collection中的集合称为单列集合，Map中的集合称为双列集合。 需要注意的是，Map中的集合不能包含重复的键,值可以重复;每个键只能对应一一个 java. util.Map<k,v>集合 Map集合的特点: Map集合是一个双列集合,一个元素包含两个值(一
网络通信概述
qq_42832437的博客
07-06 603
1. 软件结构 C/S结构:全称为Clieht/Server结构,是指客户端和服务器结构。常见程序有QQ、迅雷等软件。 B/S结构:全称为Browser/Server结构,是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。 两种架构各有优势,但是无论哪种架构，都离不开网络的支持。网络编程,就是在一定的协议下,实现两台计算机 的通信的程序。 2. 网络通信协议 ●网络通信协议:通过计算机网络可以使多台计算机实现连接,位于同一一个网络中的计算机在进行连接和通信时 需要遵守一定的规则,这就好比在道路中行驶的汽
数据库表的CRUD操作
qq_42832437的博客
07-10 551
1. DDL操作表的CRUD操作 R(Retrieve) :查询 C(Create):创建 U(Update) :修改 D(Delete) :删除 ①查询 show tables ;查询某个数据库中所有的表名称。 查看mysql的数据表： use mysql; show tables; desc 表名; 查询表结构 ②创建 语法: create table表名( 列名1数据类型1, 列名2数据类型2, 列名n数据类型n ); 注意:最后一列，不需要加逗号(,) 数据库类型: int :整数类型
数据库表中记录的基本操作
qq_42832437的博客
07-14 478
d’s’f
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值