Java学习（9）—— 多线程

已于 2023-02-11 15:45:14 修改
阅读量834 收藏 1
点赞数
分类专栏： Java 文章标签： java
于 2021-11-01 18:03:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Archer__13/article/details/121031312
版权

一.   多线程的创建

1. 方式一：继承Thread类

（1）创建一个继承于Thread类的子类；

（2）重写Thread类的run()：将此线程要执行的操作声明在run()中；

（3）创建子类对象；

（4）通过此对象调用start()：启动当前线程，调用当前线程的run()；

注意：不能直接调用run()来启动线程；如果想再启动一个线程来执行该任务，需要再创建一个对象来调用start()；如果想同时启动多个不同任务的线程，需要创建多个任务的子类，再分别创建对应的对象来调用start()。

public class Test{
    public static void main(String[] args) {
        MyThread1 thread = new MyThread1();
        thread.start();

        MyThread1 thread1 = new MyThread1();
        thread1.start();

        MyThread2 thread2 = new MyThread2();
        thread2.start();

    }

}

class MyThread1 extends Thread{
    @Override
    public void run() {
        for(int i = 0; i <= 100; i++){
            if(i % 2 == 0){
                System.out.println("偶数" + i);
            }
        }
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i = 0; i <= 100; i++){
            if(i % 2 != 0){
                System.out.println("奇数" + i);
            }
        }
    }
}
//使用匿名子类方式启动多线程
public class Test{
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for(int i = 0; i <= 100; i++){
                    if(i % 2 == 0){
                        System.out.println("偶数" + i);
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                for(int i = 0; i <= 100; i++){
                    if(i % 2 != 0){
                        System.out.println("奇数" + i);
                    }
                }
            }
        }.start();
        
    }
}

2. 方式二：实现Runnable接口（通常优先考虑使用这种方式）

（1）创建一个实现了Runnable接口的类；

（2）实现类去重写Runnable中的抽象方法：run()；

（3）创建实现类的对象；

（4）创建Thread类的对象，将实现类的对象作为参数传递到Thread类的构造器中；

（5）通过Thread类的对象调用start()。

public class Test{
    public static void main(String[] args) {
        MyThread mythread = new MyThread();     //3:创建实现类的对象
        Thread thread = new Thread(mythread);   //4:创建Thread类的对象，将实现类的对象作为参数传递到Thread类的构造器中
        thread.start();                         //5:通过Thread类的对象调用start()

        Thread thread2 = new Thread(mythread);   //启动另一个线程
        thread2.start();
    }
}

class MyThread implements Runnable{         //1:创建一个实现了Runnable接口的类
    @Override
    public void run() {                     //2:实现类去重写Runnable中的抽象方法
        for(int i = 0; i <= 100; i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
//使用匿名子类方式启动多线程
public class Test{
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i <= 100; i++){
                    if(i % 2 == 0){
                        System.out.println("偶数" + i);
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i <= 100; i++){
                    if(i % 2 != 0){
                        System.out.println("奇数" + i);
                    }
                }
            }
        }).start();

    }
}

3. Thread类中的方法：

（1）start()：启动当前线程，调用当前线程的run()；

（2）run()：通常需要重写此方法，将该线程要执行的操作声明在此方法中；

（3）currentThread()：静态方法，返回执行当前代码的线程；

（4）getName()：获取当前线程的名字；

（5）setName()：设置当前线程的名字；

public class Test{
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.setName("线程1");
        thread.start();

        Thread.currentThread().setName("主线程");
        for(int i = 0; i <= 100; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

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

            （6）yield()：释放当前线程CPU的执行权；

            （7）join()：在线程A中调用线程B的join()，此时线程A进入阻塞状态，直到线程B全部执行结束后，线程A才解除阻塞状态；

            （8）stop()：强制结束当前线程；

            （9）sleep()：让当前线程 “睡眠” 指定时间，在睡眠期间，该线程是阻塞状态；

           （10）isalive()：判断当前线程是否存活。     

4. 线程的优先级：

    优先级分为：MAX_PRIORITY：10    MIN_PRIORITY：1    NORM_PRIORITY：5  

    获取线程的优先级：getPriority()

    设置线程的优先级：setPriority(int p)

     注意：高优先级的线程要抢占低优先级线程CPU的执行权，高优先级的线程以高概率优先执行，但是不意味着只有高优先级的线程全部执行完之后，低优先级的线程才执行。

public class Test{
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.setName("线程1");
        thread.setPriority(Thread.MAX_PRIORITY);
        thread.start();

        Thread.currentThread().setName("主线程");
        for(int i = 0; i <= 100; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority());
            }
        }
    }
}

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

二.   线程同步

       例：卖票 —— 创建三个售票窗口，总票数为100张

public class Test{
    public static void main(String[] args) {
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口一");
        window2.setName("窗口二");
        window3.setName("窗口三");

        window1.start();
        window2.start();
        window3.start();
    }
}

class Window extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}
public class Test{
    public static void main(String[] args) {
        Window window = new Window();

        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);

        thread1.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

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

class Window implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }

    }
}

        注意：上述例子多个线程共同操作同一个数据，会存在线程的安全问题

        解决方法：当线程A在操作ticket时，其他线程不能参与进来，直到线程A操作完ticket时（即使线程A出现了阻塞），其他线程才可以操作ticket。

1. 同步代码块

            synchronized(同步监视器){

                        多个线程需要同步的代码

            } 

            说明：（1）同步的代码是指操作共享数据的代码，共享的数据是指多个线程共同操作的变量；

                       （2）任何一个类的对象都可以充当同步监视器（锁），所有线程必须共用一把锁。

            注意：该方法在操作同步代码块时，实际上是单线程，只有一个线程参与，其他线程等待。

public class Test{
    public static void main(String[] args) {
        Window window = new Window();

        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);

        thread1.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

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

class Window implements Runnable{
    private int ticket = 100;
    Object object = new Object();

    @Override
    public void run() {
        while(true){
            synchronized(object){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}
public class Test{
    public static void main(String[] args) {
        Window window = new Window();

        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);

        thread1.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

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

class Window implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            synchronized(this){    //this指代创建的唯一对象window
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}
public class Test{
    public static void main(String[] args) {
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口一");
        window2.setName("窗口二");
        window3.setName("窗口三");

        window1.start();
        window2.start();
        window3.start();
    }
}

class Window extends Thread{
    private static int ticket = 100;
    static Object object = new Object();

    @Override
    public void run() {
        while(true){
            //synchronized(this){  错误，这里的this指代三个对象
            synchronized(object){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}
public class Test{
    public static void main(String[] args) {
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口一");
        window2.setName("窗口二");
        window3.setName("窗口三");

        window1.start();
        window2.start();
        window3.start();
    }
}

class Window extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            //synchronized(this){  错误，这里的this指代三个对象
            synchronized(Window.class){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

2.同步方法

           同步方法仍然涉及到锁，只是不用显示的声明，非静态的同步方法中锁是this，静态的同步方法中锁是当前类本身。

public class Test{
    public static void main(String[] args) {
        Window window = new Window();

        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);

        thread1.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

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

class Window implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            show();
        }
    }

    public synchronized void show(){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                ticket--;
            }
        }
}
public class Test{
    public static void main(String[] args) {
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口一");
        window2.setName("窗口二");
        window3.setName("窗口三");

        window1.start();
        window2.start();
        window3.start();
    }
}

class Window extends Thread{
    private static int ticket = 100;
    static Object object = new Object();

    @Override
    public void run() {
        while(true){
            show();
        }
    }

    //错误：public synchronized void show(){
    public static synchronized void show(){
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
            ticket--;
        }
    }
}

3.使用Lock锁

import java.util.concurrent.locks.ReentrantLock;

public class Test{
    public static void main(String[] args) {
        Window window = new Window();

        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);

        thread1.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

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

class Window implements Runnable{
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{
                lock.lock();
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                lock.unlock();
            }

        }
    }
}

         synchronized与Lock的异同：（1）相同：都用来解决线程安全问题；（2）不同：synchronized在执行完同步代码之后自动解开锁，Lock需要手动启动同步（lock()），结束同步时需要手动解锁（unlock()）。

三.   线程通信

        例子：使用两个线程交替打印1-100

public class Test{
    public static void main(String[] args) {
        Printer printer = new Printer();

        Thread thread1 = new Thread(printer);
        Thread thread2 = new Thread(printer);

        thread1.setName("打印一");
        thread2.setName("打印二");

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

class Printer implements Runnable{
    private int number = 1;

    @Override
    public void run() {
        while(true){
            synchronized (this){
                notify();   //唤醒被阻塞的线程       省略的是this.

                if(number <= 100){
                    System.out.println(Thread.currentThread().getName() + "，" + number);
                    number++;

                    try{ 
                        wait();   //调用wait方法使线程进入阻塞状态        省略的是this.
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }
        }
    }
}

         wait()：一旦执行此方法，当前线程进入阻塞状态，释放锁

         notify()：一旦执行此方法，就会唤醒被wait()的一个线程，如果多个线程被wait()，就唤醒优先级高的那个。

         notify()：一旦执行此方法，就会唤醒所有被wait()的线程。

         注意：wait()、notify()、notify()只能使用在同步代码块或同步方法中，且只能被同步监视器调用。

         sleep与wait的不同：（1）sleep()声明在Thread类中，wait()声明在Object类中；（2）sleep()可以在任何情况下调用，wait()只能使用在同步代码块或同步方法中；（3）如果两个方法都使用在同步代码块或同步方法，sleep()不会释放同步监视器，wait()会释放同步监视器。

四.   创建多线程的两种新方式

1. 新方式一：实现Callable接口

          （1）创建一个实现了Callable接口的类；

          （2）实现类去重写Callable中的call()方法，将此线程需要执行的操作声明在call()中，此方法可以有返回值；

          （3）创建Callable接口实现类的对象；

          （4）创建FutureTask类的对象，将实现类的对象作为参数传递到FutureTask类的构造器中；

          （5）创建Thread类的对象，将FutureTask类的对象作为参数传递到Thread类的构造器中；

          （6）通过Thread类的对象调用start()。

          （7）可以使用get()方法获取Callable中call()方法的返回值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test{
    public static void main(String[] args) {
        MyThread mythread = new MyThread();
        FutureTask futureTask = new FutureTask(mythread);
        Thread thread = new Thread(futureTask);
        thread.start();

        try{
            Object sum = futureTask.get();
            System.out.println("总和：" + sum);
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch(ExecutionException e){
            e.printStackTrace();
        }


    }
}

class MyThread implements Callable {
    @Override
    public Object call() throws Exception{
        int sum = 0;
        for(int i = 0; i <= 100; i++){
            if(i % 2 == 0){
                System.out.println(i);
                sum+= i;
            }
        }
        return sum;
    }
}

2. 新方式二：使用线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test{
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);  //创建一个固定线程数量的线程池

        MyThread1 mythread1 = new MyThread1();
        executorService.execute(mythread1);   //用于实现Runnable接口
        //executorService.submit();   用于实现Callable接口

        MyThread2 mythread2 = new MyThread2();
        executorService.execute(mythread2);

        executorService.shutdown();    //关闭线程池

    }
}

class MyThread1 implements Runnable {
    @Override
    public void run(){
        for(int i = 0; i <= 100; i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + "，" + i);
            }
        }
    }
}

class MyThread2 implements Runnable {
    @Override
    public void run(){
        for(int i = 0; i <= 100; i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + "，" + i);
            }
        }
    }
}
Yacht13
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 多线程（二）——创建线程（Thread、Runnable、Callable）
添仔哥哥
03-04 2663
采用实现Runnable、Callable接口的方式创建多线程； 采用继承Thread类的方式创建多线程；
java new thread()_(一)java多线程之Thread
weixin_39619478的博客
02-16 6301
Thread类学习java线程的开发者,首先遇到的第一个类就是Thread,通过使用Thread类,我们就可以启动,停止,中断一个线程. 在同一个时间片里, 可能会有多个线程在执行, 每个线程都拥有它自己的方法调用堆栈, 参数和变量.每个app至少会有一个线程--主线程(main thread).创建一个线程java创建线程有两种方式创建一个继承Thread的子类,并实现run方法使用Thread...
JAVA多线程
水月洞天
06-23 579
1 多线程概述 1:要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。 2:什么是进程? 通过任务管理器我们就看到了进程的存在。 而通过观察，我们发现只有运行的程序才会出现进程。 进程：就是正在执行的应用程序。 进程是系统进行资源分配和调用的独立单位。 每一个进程都有它自己的内存...
Java多线程（二）：线程的常用方法和状态_&quot；java的new thread (thread, &quot；窗口1 &quot；)(1)
最新发布
2401_84975387的博客
05-16 352
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取 TimeUnit.DAYS.sleep(1);//天 TimeUnit.HOURS.sleep(1);//⼩时 TimeUnit.MINUTES.sleep(1);//分 TimeUnit.SEC
Java多线程
hashmapdemo的博客
04-20 1426
目录 1、多线程技术概述 2、多线程的实现 3、Thread类详解 4、线程的休眠、阻塞及中断 5、守护线程 6、线程安全问题（使用锁） 7、多线程通信（生产者与消费者） 8、线程的六种状态 9、线程池 一、多线程技术概述 1、线程与进程 进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 线程： 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的
Java多线程---线程的创建(Thread类的基本使用)
weixin_56952690的博客
05-08 1342
本文主要介绍Java多线程的相关知识, Thread的创建, 常用方法的介绍和使用, 线程状态等.
Java进阶学习——Java多线程知识的理解
01-20
Java多线程知识的理解0.前言1.从一道题目引入2.创建线程2.1.继承Thread类2.2.实现Runnable接口3.线程的生命周期4.线程安全4.1.为什么需要线程安全？4.2.如何实现线程安全？5.线程池5.1.为什么需要线程池？5.2.创建...
JAVA面试题——多线程.docx
06-12
JAVA面试题——多线程
Java多线程基础——Lock类
08-31
Java多线程基础中的Lock类提供了比`synchronized`更强大的同步控制能力。Lock是一个接口，它定义了比`synchronized`更灵活的锁定机制，允许更细粒度的控制。在Java 1.5及之后的版本中引入，Lock类的主要目的是提高...
Java——多线程编程技术.pdf
12-31
"Java多线程编程技术.pdf" Java多线程编程技术是Java平台的一个重要技术优势，是第一个直接把跨平台线程模型和标准的内存模型集成到语言中的主流语言。多线程编程技术是Java平台的一个重要技术优势，它可以使程序的...
Java练手小项目——多线程聊天室.zip
01-14
【Java练手小项目——多线程...通过这个“Java练手小项目——多线程聊天室”，你可以深入了解Java多线程的原理和实践，同时学习到网络编程和并发集合的运用，这对于提升你的Java编程技能和解决实际问题的能力大有裨益。
Java多线程：常见的线程的创建方法及Thread类详解
luming的博客
05-07 1167
线程是程序的执行流程的最小单元，一个进程（程序的执行实例）可以由一个或多个线程组成，每个线程都有自己的执行路径和执行状态。线程可以并发执行，即多个线程可以同时在不同的处理器核心或计算机上运行，从而提高程序的运行效率。线程与进程的区别在于，进程是操作系统对一个正在运行的程序的抽象，而线程是进程内部的一个执行单位。一个进程可以有多个线程，这些线程共享进程的资源，如内存空间、文件描述符等。线程之间可以通过共享内存的方式进行通信，相比于进程间通信（如管道、消息队列）的开销更小。
初识java多线程（Thread）
weixin_46972127的博客
03-24 2820
1、认识线程 1.1概念 线程组成了进程，进程是操作系统分配资源的最小单元，而线程是操作系统调度的最小单位，一个线程就是一个执行流，每个线程有自己独立的代码，多个线程之间“同时”执行着多份代码。 1.2为什么要有线程 “并发编程”成为刚需，单核CPU的发展遇到瓶颈，想要提高算力，需要多核CPU（可以简单地理解为多个CPU组成），虽然多进程也能实现“并发编程”，但线程比进程更加轻量： ①创建线程比创建进程更快 ②销毁线程比销毁进程更快 ③调度线程比调度进程更快 ※进程和线程地区别： ①从
Java 四种线程池 & new Thread
weixin_41074208的博客
05-17 318
转载https://www.cnblogs.com/zhujiabin/p/5404771.html1、new Threadnew Thread(new Runnable() { @Overridepublic void run() {// TODO Auto-generated method stub}}).start();1. 每次new Thread新建对象性能差。2. 线程缺乏统一管理，可...
Java线程
m0_56188609的博客
02-22 2272
两个线程同时运行均要使用CPU，While(ture)为死循环，两个线程均需要不断使用CPU，而两个线程大量使用CPU会造成CPU占用率达到100%，其他代码、操作系统其他程序就会暂停卡住。因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码（从使用CPU到不适用CPU称之为线程的一次上下文切换）当然它的底层是否由多个核心对这两个线程并行执行还是一个核心对它们并发处理，包括打印的前后顺序是不由我们控制的。（快照：只能查看某一刻） 查看某个 Java 进程（PID）的所有线程状态。
Java创建多线程的五种写法
qq_62718027的博客
06-21 2169
其实就是在Thread里面多了一个new Runnable。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)​​​​​​​。(线程和主程序运行结果可能会调换顺序)
Java中Thread类的基本用法
m0_67683346的博客
08-19 5868
Java中的Thread类的基本使用
Java多线程Thread详细讲解（万字教程）
zhendeC1的博客
04-09 803
你也可以直接new一个Thread类，并且临时重写run方法（少写一个类）@OverrideSystem.out.println(Thread.currentThread().getName() + “执行了！”);}.start();Java如何开启线程？方式2：实现Runnable接口！（详细讲解）这种方式的本质还是第一种，即Thread类实例调用start方法，从而去调用本地线程资源。因为。
java new Thread(Runnable) 干了什么？
wangjun5159的专栏
12-27 2674
一直很好奇，new Thread()干了什么？有没有性能消耗 构造方法如下，如果没指定线程名字，默认是 "Thread-" + nextThreadNum() 格式 /** * Allocates a new {@code Thread} object. This constructor has the same * effect as {@linkplain #Thr...
Java多线程基础：创建与概念模型详解
这个PPT主要介绍了Java多线程的基础，包括创建线程的基本步骤和线程概念模型，为后续深入学习线程并发编程打下基础。如果你需要深入了解Java多线程的高级特性，如并发容器、Future和Callable接口、Executor框架等，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值