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多线程学习（三）——线程栈
hust_superman的专栏
09-19 5614
一、线程栈模型 线程栈模型是理解线程调度原理以及线程执行过程的基础。线程栈是指某时刻时内存中线程调度的栈信息，当前调用的方法总是位于栈顶，线程栈的内容是随着线程的运行状态变化而变化的，研究线程栈必须选择一个运行的时刻(指代码运行到什么地方) 上图中的栈A是主线程main的运行栈信息，当执行new JavaThreadDemo().threadMethod();方法时，threadMet
Java多线程学习（九）CyclicBarrier学习
wanderlustLee的博客
02-26 504
CyclicBarrier类似于闭锁，但是CyclicBarrier要等待一组线程同时到达某个屏障，先到达的线程要等待其他线程到达，等达到了屏障要求的线程数量，这些线程才能继续执行。 API中的解释：CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待...
new Thread(new Runnable(){})
热门推荐
麦七的博客
08-10 3万+
JAVA是面向对象的，也就是说，对于一个方法等，它需要什么类型的对象，只要传入就可以了。 像这里，Thread类的构造方法中，需要一个实现了Runnable接口的对象，而new就是生成了个Runnable接口下的一个实例对象。 同等与这种写法，实例化了一个Runnable接口子类的实例 Thread t=new Thread(new MyRunnable()); public class MyRunnable implements Runnable{ @Override public void run(
Java多线程
hashmapdemo的博客
04-20 1427
目录 1、多线程技术概述 2、多线程的实现 3、Thread类详解 4、线程的休眠、阻塞及中断 5、守护线程 6、线程安全问题（使用锁） 7、多线程通信（生产者与消费者） 8、线程的六种状态 9、线程池 一、多线程技术概述 1、线程与进程 进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 线程： 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的
Java多线程（二）：线程的常用方法和状态_&quot；java的new thread (thread, &quot；窗口1 &quot；)(1)
最新发布
2401_84975387的博客
05-16 354
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取 TimeUnit.DAYS.sleep(1);//天 TimeUnit.HOURS.sleep(1);//⼩时 TimeUnit.MINUTES.sleep(1);//分 TimeUnit.SEC
Java中Thread类的基本用法
m0_67683346的博客
08-19 5874
Java中的Thread类的基本使用
new Thread() 的危害
qq_34253002的博客
09-07 5829
1）开销大 每次new Thread() 都会创建新的对象，开销较大，无法复用增加垃圾回收的负担。 2）管理困难 每个newThread() 都是独立的个体，无法有效的管控，无限制创建相互竞争，可能导致oom或者核心业务线程阻塞。 3）功能单一 无法定时执行，中断线程等功能。
线程系列二：Thread构造函数
sys的博客
12-13 1675
线程系列二：Thread构造函数 文章目录线程系列二：Thread构造函数前言一、new Thread二、与jVM1.与内存的关系2.线程创建的数量三、守护线程 前言 在我们开始学线程的时候新建一个线程用的什么？new Thread()相信大家都很熟悉，不知道大家有没有深入理解过这个函数 一、new Thread 有一下几个知识点: new Thread(“t1”) 可以传入一个参数作为线程的名字，如果没有会默以"Thread-"作为前缀递增 在线程是new状态时可以修改线程名字其他状态将不能修
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线程
m0_56188609的博客
02-22 2292
两个线程同时运行均要使用CPU，While(ture)为死循环，两个线程均需要不断使用CPU，而两个线程大量使用CPU会造成CPU占用率达到100%，其他代码、操作系统其他程序就会暂停卡住。因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码（从使用CPU到不适用CPU称之为线程的一次上下文切换）当然它的底层是否由多个核心对这两个线程并行执行还是一个核心对它们并发处理，包括打印的前后顺序是不由我们控制的。（快照：只能查看某一刻） 查看某个 Java 进程（PID）的所有线程状态。
【多线程】Thread 类及常见方法
m0_60494863的博客
05-14 5011
1.Thread 类 在Java标准库中，提供有一个Thread,来表示/操作线程。 Thread 类也可以视为Java 标准库提供的API。 创建好的 Thread 实例，其实和操作系统中的线程是一一对应的关系。 操作系统，提供了一组关于线程API（C语言风格），Java对于这组API进一步封装了，就成了Thread类 2.创建线程 2.1继承Thread 类 通过Thread 类创建线程，最基本的做法就是创建子类，继承自Thread ，并且重写run方法 （1）继承Thread 来创建一
Java多线程学习(二)---线程创建方式
weixin_33912246的博客
08-12 178
线程创建方式 摘要： 1. 通过继承Thread类来创建并启动多线程的方式 2. 通过实现Runnable接口来创建并启动线程的方式 3. 通过实现Callable接口来创建并启动线程的方式 4. 总结Java中创建线程的方式，比较各自优势和区别 一、继承Thread类创建线程类 1.1 继承Thread类创建线程步骤 Java使用Thread类代表线程，所有的线程对象都必须是Th...
线程（1）
weixin_60475929的博客
01-25 405
线程 线程（thread）是一个程序内部的一条执行路径 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径 程序中只有一条执行路径，那么这个程序就是单线程的程序 多线程 概述 多线程是指从软硬件上实现多条执行流程的技术 多线程的作用 多线程的创建 方式一：继承Thread类 Thread类： Java是通过java.lang.Thread类来代表线程 按照面向对象的思想，Thread类应该提供多线程的方式 方案： 缺点； 线程类已...
java多线程——Thread类基本用法
weixin_60778429的博客
07-23 2333
本文主要用于总结多线程中Thread类的基本用法，不会涉及太多知识点，若想翻看更多有关多线程的知识点可看往期有关多线程的文章java多线程基础（中）_invictusQAQ的博客-CSDN博客。
Java Thread类的基本用法
Naion的博客
07-23 3342
简单介绍了Java中Thread类的几个基本的知识点。
Java多线程编程实战指南
"Java多线程编程深入详解" 在Java编程中，多线程是并发执行任务的关键技术，它使得程序能够同时处理多个任务，提高了系统资源的利用率和程序的响应速度。本书深入探讨了Java多线程的概念、实现方式以及相关实践。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值