Java基础（29）线程与进程、并发与并行、多线程的三种启动方式、买票案例

最新推荐文章于 2024-07-06 13:51:47 发布
最新推荐文章于 2024-07-06 13:51:47 发布
阅读量639 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nswzr/article/details/106491664
版权

1. 进程与线程

1. 进程与线程的概述：

（1）进程：

  • 进程就是正在运行的程序，是系统进行资源分配和调用的独立单位，每一个进程都有他自己的内存空间和系统资源
  • 比如正在运行的应用程序（QQ，微信，QQ音乐）

（2）多进程

  • 现在的计算机系统（Win，Mac，Linux）是支持多进程的，可以同时运行多个程序
  • 我们的计算机在同一个时间点上，是同时执行多个进程吗？不是，我们的（单核CPU）CPU在同一个时间点上只能执行一个进程
  • 你的感觉多个进程在同时执行，因为CPU在某个时间点上只能做一件事情，CPU在多个进程间进行一个高速的切换执行，你的人耳和眼睛根本就感觉不到
  • 多进程的意义：多进程的作用不是提高执行速度，而是提高CPU的使用率

（3）线程

  • 在进程开启后，会执行多个任务，每一个任务就称为一个线程（比如QQ音乐，听歌是一个线程，显示歌词是一个线程）
  • 线程依赖于进程而存在，一个进程中至少有一个线程
  • 线程是程序使用CPU的基本单位。所以，进程是拥有资源的基本单位，线程是CPU调度的基本单位
  • 多线程的意义：多线程的作用不是提高执行速度，而是为了提高应用程序的使用率

2. 并发与并行

1. 并发

  • 指的是多个任务，高速的交替执行
  • 比如说：吃一口饭喝一口水

2. 并行

  • 指的是多个任务同时执行
  • 比如说：边吃饭边打电话

3. Java程序的运行原理

  1. Java命令会启动Java虚拟机（JVM），启动JVM等于启动了一个程序，也就是启动了一个进程
  2. 该进程会自动启动一个"主线程"，主线程会去调用某个类中的main方法。所以main方法运行在主线程中
  3. JVM的启动是多线程的吗：JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的

4. 多线程的启动方式1：继承Thread类

1. Java给我们提供好了一个Thread类，通过Thread类创建线程和开启线程

2. 创建新线程的方法

  • 将一个类声明为Thread的子类
  • 该子类重写Thread类中的run()方法
  • 分配并启动该子类的示例

3. 注意事项：

  • run()方法中写的一般是比较耗时的代码
  • 同一个线程在一个程序中不要重复开启，重复开启会抛出异常
public class TestDemo01 {
    public static void main(String[] args) {
        System.out.println("主线程的代码1");
        System.out.println("主线程的代码2");

        System.out.println("当主线程执行到这块的时候，开启多线程");
        MyThread myThread1 = new MyThread();
        myThread1.start();

        System.out.println("myThread后面的代码1");
        System.out.println("myThread后面的代码2");

        System.out.println("在开启一条线程");

        MyThread myThread2 = new MyThread();
        myThread2.start();

        System.out.println("最后的代码1");
        System.out.println("最后的代码2");
    }
}

class MyThread extends Thread{
    /**
     * run()方法里面的代码写的是比较耗时的代码，让子线程来进行
     * 模拟耗时操作
     */
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

4. 获取和设置线程的名称

  • 获取和设置线程名称的方法
	public final String getName()  //获取线程名称
	public final void setName(String name)   //设置线程名称
	public MyThread(String name) {
        super(name);
    }       //通过构造方法直接设置线程名
	public static Thread currentThread()   //获取当前执行的线程
  • 代码示例
public class TestDemo01 {
    public static void main(String[] args) {
        Thread thMain = Thread.currentThread();
        thMain.setName("主线程");
        System.out.println(thMain.getName());

        //多个线程并发执行，多个抢占CPU的执行权，哪个线程抢到，在某一个时刻，就会执行哪个线程。线程的执行具有随机性
        MyThread th1 = new MyThread();
        th1.setName("艾欧尼亚");
        th1.start();

        MyThread th2 = new MyThread();
        th2.setName("诺克萨斯");
        th2.start();

        MyThread th3 = new MyThread();
        th3.setName("战争学院");
        th3.start();
    }
}

class MyThread extends Thread{

    //无参构造
    public MyThread() {
    }
    //有参构造：设置线程名
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //Thread.currentThread().getName()：获取当前线程的名称
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

5. 代码示例：使用多线程来复制音乐和文本文件

public class TestDemo01 {
    public static void main(String[] args) {
        System.out.println("主线程执行");

        copyMp3Thread th1 = new copyMp3Thread();
        th1.start();

        copyTxtThread th2 = new copyTxtThread();
        th2.start();

        System.out.println("主线程后面的代码1");
        System.out.println("主线程后面的代码2");
        System.out.println("主线程后面的代码3");
    }
}

class copyMp3Thread extends Thread{
    @Override
    public void run() {
        //ctrl+alt+t：快速try/catch
        try {
            FileInputStream fis = new FileInputStream("阿刁_赵雷.mp3");
            FileOutputStream fos = new FileOutputStream("newMp3.mp3");

            byte[] bytes = new byte[1024 * 8];
            int len = 0;
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
                fos.flush();
            }

            fis.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class copyTxtThread extends Thread{
    @Override
    public void run() {
        try {
            BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("newAaa.txt"));

            String line = null;
            while ((line = br.readLine()) != null){
                bw.write(line);
                bw.newLine();
                bw.flush();
            }

            bw.close();
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6. 线程调度及设置线程优先级

（1）线程的调度模型：

  • 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用的CPU时间片
  • 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，则随机选取一个执行。线程优先级高的获取CPU时间会多一些
  • Java使用的是抢占式调度模型

（2）获取和设置线程的优先级

	public final int getPriority()   //获取线程的优先级
	public final void setPriority(int newPriority)   //设置线程的优先级
	【注意】
		1.线程优先级共分成1~10,1是最低优先级（Thread.MIN_PRIORITY == 1），10是最高优先级（Thread.MAX_PRIORITY == 10）
		2.线程的默认优先级是5（Thread.NORM_PRIORITY == 5）

（3）注意事项：有的时候我们给线程设置了指定的优先级,但是该线程并不是按照优先级高的线程执行,那是为什么呢?

  • 因为线程的优先级的大小仅仅表示这个线程被CPU执行的概率增大了.但是我们都知道多线程具有随机性
  • 所以有的时候一两次的运行说明不了问题

（4）代码示例

public class TestDemo02 {
    public static void main(String[] args) {
        MyThread th1 = new MyThread();
        MyThread th2 = new MyThread();
        MyThread th3 = new MyThread();

        th1.setName("艾欧尼亚");
        th2.setName("诺克萨斯");
        th3.setName("战争学院");

        //设置线程优先级
        th1.setPriority(Thread.MIN_PRIORITY);
        th2.setPriority(Thread.MAX_PRIORITY);
        th3.setPriority(Thread.NORM_PRIORITY);
        
        //获取线程优先级
        System.out.println(th1.getPriority());   //1
        System.out.println(th2.getPriority());   //10
        System.out.println(th3.getPriority());   //5

        th1.start();
        th2.start();
        th3.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

7. 线程控制

（1）睡眠线程：public static void sleep(long millis)：设置线程睡眠，单位：毫秒

public class TestDemo01 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开启了");
        Thread.sleep(1000);
        System.out.println("主线程接着执行");

        MyThread th1 = new MyThread("A线程");
        MyThread th2 = new MyThread("B线程");

        th1.start();
        th2.start();
    }
}

class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

（2）加入线程：public final void join()

  • 意思就是：等待该线程执行完毕了以后, 其他线程才能再次执行
  • 注意事项:
    在线程启动之后, 在调用方法
    join ()可以让多个线程并发执行，变成串行（挨个排队执行，不用抢）
public class TestDemo01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread th1 = new MyThread("艾欧尼亚");
        MyThread th2 = new MyThread("诺克萨斯");
        MyThread th3 = new MyThread("战争学院");

        //注意：在线程启动之后, 在调用join()方法
        th1.start();
        th1.join();
        th2.start();
        th2.join();
        th3.start();
        th3.join();

        /**
         * 艾欧尼亚--->0
         * 艾欧尼亚--->1
         * 艾欧尼亚--->2
         * 艾欧尼亚--->3
         * 艾欧尼亚--->4
         * 艾欧尼亚--->5
         * 艾欧尼亚--->6
         * 艾欧尼亚--->7
         * 艾欧尼亚--->8
         * 艾欧尼亚--->9
         * 诺克萨斯--->0
         * 诺克萨斯--->1
         * 诺克萨斯--->2
         * 诺克萨斯--->3
         * 诺克萨斯--->4
         * 诺克萨斯--->5
         * 诺克萨斯--->6
         * 诺克萨斯--->7
         * 诺克萨斯--->8
         * 诺克萨斯--->9
         * 战争学院--->0
         * 战争学院--->1
         * 战争学院--->2
         * 战争学院--->3
         * 战争学院--->4
         * 战争学院--->5
         * 战争学院--->6
         * 战争学院--->7
         * 战争学院--->8
         * 战争学院--->9
         */
    }
}

class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

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

（3）礼让线程：public static void yield()：暂停当前执行程序，并执行其他的线程【用处不大】

public class TestDemo01 {
    public static void main(String[] args) {
        MyThread th1 = new MyThread("艾欧尼亚");
        MyThread th2 = new MyThread("诺克萨斯");

        th1.start();
        th2.start();
    }
}

class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

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

（4）守护线程：public final void setDaemon(boolean on)：将该线程标记为守护线程

  • true：开启守护线程。false：关闭守护线程
  • 当正在运行的线程都是守护线程时，JVM退出，守护线程就立马死掉
  • 该方法必须在启动线程前调用
public class TestDemo01 {
    public static void main(String[] args) {
        Thread.currentThread().setName("刘备：主线程");
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }

        MyThread th1 = new MyThread("关羽");
        MyThread th2 = new MyThread("张飞");
        th1.setDaemon(true);
        th2.setDaemon(true);
        th1.start();
        th2.start();

    }
}

class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

5. 创建线程的第二种方式：Runnable接口

1. 创建线程的第二种方式
（1）定义一个类实现Runnable接口
（2）重写该接口的run()方法
（3）然后可以分配该类的实例
（4）在创建Thread对象时作为一个参数来传递并启动

2. 这种方式扩展性强，实现一个接口，还可以再去继承其他类

3. 代码示例

public class TestDemo01 {
    public static void main(String[] args) {
        MyRunnable1 myRunnable1 = new MyRunnable1();
        Thread th1 = new Thread(myRunnable1);
        th1.setName("A线程");
        MyRunnable2 myRunnable2 = new MyRunnable2();
        Thread th2 = new Thread(myRunnable2);
        th2.setName("B线程");

        th1.start();
        th2.start();
    }
}

class MyRunnable1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

class MyRunnable2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

6. 创建线程的第三种方式：实现Callable接口

1. 创建线程的第三种方式：
（1）创建一个类实现Callable 接口，重写接口中的call方法
（2）创建一个FutureTask类将Callable接口的子类对象作为参数传进去
（3）创建Thread类, 将FutureTask对象作为参数传进去
（4）开启线程

2. 这种创建线程的方式可以有返回值

3. 代码示例

public class TestDemo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable(100);
        FutureTask<Integer> task = new FutureTask<>(myCallable);
        Thread th = new Thread(task);
        th.start();

        //获取线程的执行结果
        Integer sum = task.get();
        System.out.println(sum);
    }
}

class MyCallable implements Callable<Integer> {
    private int num;

    public MyCallable(int num) {
        this.num = num;
    }

    @Override
    public Integer call() throws Exception {
        //求1~num之间的和
        int sum = 0;
        for (int i = 1; i <= num ; i++) {
            sum += i;
        }
        return sum;
    }
}

7. 买电影票案例

1. 需求：某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票

2. 继承Thread类的方式实现

public class TestDemo01 {
    public static void main(String[] args) {
        SaleTicketThread th1 = new SaleTicketThread("窗口1");
        SaleTicketThread th2 = new SaleTicketThread("窗口2");
        SaleTicketThread th3 = new SaleTicketThread("窗口3");

        th1.start();
        th2.start();
        th3.start();
    }
}

class SaleTicketThread extends Thread{
    //设置票数，把票数设置为共享变量，让三个线程来共享
    static int ticket = 100;

    public SaleTicketThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true){
            if (ticket >= 1){
                System.out.println(Thread.currentThread().getName() + "正在出售第：" + ticket-- + "张票");
            }
        }
    }
}

3. 实现Runnable接口的方式实现

public class TestDemo02 {
    public static void main(String[] args) {
        SaleTicketRunnable saleTicketRunnable = new SaleTicketRunnable();
        Thread th1 = new Thread(saleTicketRunnable, "窗口1");
        Thread th2 = new Thread(saleTicketRunnable, "窗口2");
        Thread th3 = new Thread(saleTicketRunnable, "窗口3");

        th1.start();
        th2.start();
        th3.start();
    }
}

class SaleTicketRunnable implements Runnable{

    static int ticket = 100;

    @Override
    public void run() {
        while (true){
            if (ticket >= 1){
                System.out.println(Thread.currentThread().getName() + "正在出售第：" + ticket-- + "张票");
            }
        }
    }
}
wzr-xupt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python并发：多线程与多进程
02-24
线程与多线程2.进程与多进程3.多线程并发下载图片4.多进程并发提高数字运算在计算机编程领域，并发编程是一个很常见的名词和功能了，其实并发这个理念，最初是源于铁路和电报的早期工作。比如在同一个铁路系统上如何...
Python控制多进程与多线程并发数总结
09-21
本篇文章主要介绍了Python控制多进程与多线程并发数，详细讲诉了进程和线程的区别，并介绍了处理方法，有需要的朋友可以了解一下。
Java_进程线程并发并行
战士小小白的博客
11-28 386
线程相关概念 程序 是为完成特定任务、用某种语言编写的一组指令的集合 简单来说，就是我们写的代码 进程 进程是指运行中的程序，比如我们使用的QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们启动网易云音乐，又启动了一个进程，操作系统将会为网易云音乐分配内存空间。 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。 什么是线程 线程由进程创建的，是进程的一个实体。 一个进程可以拥有多个线程。 其他相关概念 单线程：同一个时刻，只
java第二天 多线程
feifa2011的专栏
03-15 506
今天看的还是面向对象下和多线程，有点饶头；面向对象中的还好点，多线程了解知识不够，还得查资料；在群共享下载到了《java就业培训教程》pdf版的；电子书看起来没感觉，总是觉得没有纸质书那样印象深刻，什么时候能适应电子书就好了。然后顺便看了eclipse的开发环境和基本介绍，还没下载，得动手了，时间不多。
Java多线程与并发以及线程池四种方式详细图解
weixin_45670060的博客
08-18 994
前言 Java多线程是很重要的一个知识点，随着业务量和数据的增加，在以后企业多线程的运用也是很多的，并且在面试中，多线程也是一个必考的高阶知识点之一。 什么是多线程？ 线程与进程 进程： 进程是程序在计算机上的一次执行活动，当你运行一个程序，你就启动了一个进程，例如运行QQ、微信，系统就会创建进程来处理我们日常的操作，打开任务管理器，进程列表里就有QQ和Wechat的.exe的运行程序如图： 程序是计算机指令的集合，它以文件的形式存储在磁盘上，即程序是静态的代码。 线程： 进程可以进一步
第七个java程序（售票系统多线程并发与互斥）
充满好奇的threecat
12-04 901
前言：      继续冲鸭，这里我们举例子来看多线程之间的并发与互斥。      首先来看看一些定义： 进程：      是表示资源分配的基本单位，又是调度运行的基本单位。例如，用户运行自己的程序，系统就创建一个进程，并为它分配资源，包括内存、磁盘、...
Java 线程01：并发并行、进程线程、3种线程创建、线程安全与锁对象
turbo小世界
05-27 296
文章目录一、线程概念1、并发与并行2、线程与进程3、线程调度二、线程1、主线程2、多线程原理多线程内存原理run()与start() 区别3、Thread类构造方法常用方法练习：通过继承线程类，开启多线程下载网络图片4、Runable接口5、Thread类 与 Runnable接口 的区别6、匿名内部类实现线程创建7、Callable\ 接口三、线程安全1、线程安全2、线程同步1）同步代码块同步代码块的原理2）同步方法3）Lock 接口 JDK 1.5 一、线程概念 1、并发与并行 并发：指两个或多个事
多线程与高并发（1）- 线程基础、并发特性、锁、JUC工具
qq_32091929的博客
02-28 957
文章目录第一章、线程基础知识一、基础概念1、什么是程序？2、什么是进程？3、什么是线程？4、什么是线程的切换（Context Switch）？5、单核CPU 设定多线程是否有意义？6、工作线程数是不是设置的越大越好？7、工作线程数（线程池中线程数量）设多少合适？二、创建线程的3 种方法1、继承Thread类 重写run方法2、实现Runnable接口 重写run方法3、实现Callable 重写call方法，配合FutureTask4、基于线程池构建线程三、线程状态四、线程的常用方法1、获取当前线程2、线程
Java并发与多线程
qqshuai9822的博客
05-18 189
开篇声明:此博客是我的学习笔记,有一些理论知识和例子说明,写的内容不是特别深,大家可以用来参考,有问题可以评论,随着学习的深入,后续还有内容会更新,想要看的可以收藏一下 #并发与多线程 在此之前,我们所学到的都是有关顺序编程的知识,即程序中的所有事物在任意时刻都只能执行一个步骤. ####什么是线程? 进程可以进一步细化为线程,是一个程序内部的一条执行路径 ####单核CPU和多核CPU? 单核CPU 是一种假的多线程,在一个时间单元内,只能执行一个线程任务 多核CPU 多核CPU才能更好的发挥多线
Java学习笔记---多线程并发
weixin_44823875的博客
03-22 1456
Java学习笔记---多线程并发认识线程和进程java中线程的实现继承Thread类（多线程实现类）实现Runnable接口（==推荐使用==）Thread类和Runnable接口线程的状态线程操作的方法同步与死锁使用同步解决使用死锁解决 认识线程和进程 进程是线程一次动态执行过程，它需要经历从代码加载、代码执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。因为每个进...
【Java基础】9.多线程与Lambda表达式
tmc1655337354的博客
05-05 413
【Java基础】9.多线程 9.1 基础概念 9.1.1 并发与并行 并发：CPU同一时间段执行多种不同的进程 并行：CPU同一时刻同时执行不同进程 9.1.2 进程 进程：进入到内存的程序。 打开Windows任务管理器可以查看合结束当前内存中的进程。【从内存中清除】 9.1.3 线程 线程：进程中的一个执行单元。一个进程中至少有一个线程。 举例： Inter Core i7 8866 4核心...
Java多线程与高并发入门到精通-视频教程网盘链接提取码下载.txt
09-08
一门专注于教授Java多线程编程和高并发处理的课程。学习者将从入门到精通，掌握多线程的概念、原理和常用技术，学会如何编写高效、安全、可靠的多线程应用程序，以及解决高并发场景下的各种问题。通过实践项目和案例...
92道Java多线程与并发面试题含答案（很全）
01-03
并发与并行：并发是指多个任务在逻辑上同时发生，而并行是指多个任务在物理上同时发生（例如在多核处理器上）。 同步（Synchronization）：同步是控制多个线程访问共享资源的方式，以防止数据不一致和竞态条件。Java...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1209
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 495
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
解决分布式环境下session共享问题
最新发布
shenxiaomo1688的博客
07-06 884
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 301
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
ShardingSphere
Casual_Lei的博客
07-04 618
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java高并发的解决方案.pdf
09-09
"Java高并发解决方案，主要...Java高并发解决方案涉及到进程与线程的理解、线程的创建与管理、线程同步与并发控制、线程池的使用以及并发集合的应用等多个方面，通过合理的设计和优化，可以构建出高性能的并发系统。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值