关于JAVA开发中多线程相关问题

最新推荐文章于 2026-06-29 16:52:08 发布
原创 最新推荐文章于 2026-06-29 16:52:08 发布 · 643 阅读 · 19 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #开发语言

一、概念

        1.线程与进程

                进程：在内存中执行的应用程序（一个进程中至少有一个线程，还可以有多个线程）

                线程：是进程中的最小执行单元（一个功能需要一条线程执行）

                在CPU和内存之间为每一个功能开辟对应的通道，方便CPU去内存中提取代码做计算，这个通道就是线程。

                一个线程干一件事，同时干多件事就可以提高CPU的利用率。

        2.并发和并行

                并行：同一时刻，有多个事情在多个CPU上同时执行。

                并发：同一时刻，有多个事情在单个CPU上交替执行。

        3.CPU调度

                分时调度：指的是让所有线程轮流获取CPU的使用权，并且平均分配每个线程占用CPU 的时间。

                抢占式调度：多个线程轮流抢占CPU使用权，哪个线程先抢到，哪个线程先执行（java程序就是抢占式调度）。

二、创建线程的方式

        1.通过继承来创建线程 （extends Thread）

                1.首先创建一个MyThread类去继承Thread方法，然后重写Thread中的run方法

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

                2.创建一个测试类Test01

public class Test01 {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        // 调用start方法, 启动线程
        t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"线程执行了:"+i);
        }
    }
}

    我们会发现一个现象，我们在控制台中，每次运行的结果都不一样。这就是发生了两个线程互相抢占CPU的使用权导致的。

        2.通过接口来创建线程（实现Runnable接口）

        首先，我们创建一个MyRunnable类去实现Runnable接口，并重写run方法，设置线程任务。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"...执行了"+i+"次");
        }
    }
}

        创建测试类TestRunnable 

public class TestRunnable {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        /**
         * Thread(Runnable target)
         */
        Thread t1 = new Thread(myRunnable);
        //调用Thread中的start方法,开启线程
        t1.start();

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"...执行了"+i+"次");
        }
    }
}

关于这两种实现多线程的方式的区别：

1.继承Thread:继承只支持单继承,有继承的局限性
2.实现Runnable:没有继承的局限性, MyThread extends （父类） implements Runnable 

        3.使用匿名内部类创建多线程 

        创建测试类noNameTest

        

public class NoNa么Thread{
    public static void main(String[] args) {
        /*
          Thread(Runnable r)
          Thread(Runnable target, String name) :name指的是给线程设置名字
         */

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"...执行了"+i+"次");
                }
            }
        },"线程1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"...执行了"+i+"次");
                }
            }
        },"线程2").start();
    }
}

1.new Thread对应了Thread t1 = new Thread（myRunnable）的红色字体

2.（new Runnable（）{

        public void run(){

                (....................方法体)

        }

}）对应了蓝色字体

        4.多线程在内存中的运行原理

        我们的程序从main方法开始运行，main方法在栈内存中开辟了空间，逐行向下执行。

        首先在堆内存中创建了MyThread对象（包括成员变量，方法表等），在栈内存中有MyThread类型的t1指向堆中MyThread的地址。

（关于内存分析，详见：关于面向对象的内存分析-CSDN博客）

        然后t1.start（）创建线程对象，会创建一个新的栈空间（属于t1线程），在t1中找run方法并运行。

        所以：开启一个线程就会开启一个新的栈空间去运行对应的线程代码。同一个线程对象不能连续调用多次start，如果想再次调用start，那就需要new一个新对象。

        5.Thread类中的主要方法

void start() -> 开启线程,jvm自动调用run方法
void run()  -> 设置线程任务,这个run方法是Thread重写的接口Runnable中的run方法
String getName()  -> 获取线程名字
void setName(String name) -> 给线程设置名字
static Thread currentThread() -> 获取正在执行的线程对象(此方法在哪个线程中使用,获取的就是哪个线程对象)   
static void sleep(long millis)->线程睡眠,超时后自动醒来继续执行,传递的是毫秒值

关于为什么在重写的run方法中有异常只能try,不能throws

原因:继承的Thread中的run方法没有抛异常,所以在子类中重写完run方法之后就不能抛,只能try...catch

        6.Thread类中的其他方法

void setPriority(int newPriority)   
-> 设置线程优先级,优先级越高的线程,抢到CPU使用权的几率越大,但是不稳定

int getPriority()  -> 获取线程优先级
  
void setDaemon(boolean on)  
-> 设置为守护线程,当非守护线程执行完毕，
守护线程就要结束,但是守护线程也不是立马结束,当非守护线程结束之后，
在告知的过程中,守护线程会执行,只不过执行到半路就结束了
  
static void yield() -> 礼让线程,让当前线程让出CPU使用权
   
void join() -> 插入线程或者叫做插队线程
        6.1.1  线程优先级

        依然沿用MyThread类

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

        创建测试类Test02

public class Test02 {
    public static void main(String[] args) {
        //创建两个线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        //更改两个线程对象的名字以便识别
        t1.setName("线程1");
        t2.setName("线程2");

        //设置两个线程优先级
        t1.setPriority(1);
        t2.setPriority(10);

        //启动两个线程
        t1.start();
        t2.start();

    }
}

线程优先级默认为5，最大值为10，最小值为1

        6.1.2  守护线程

        依然沿用MyThread类

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

        创建GuardianThread类作为守护线程

public class GuardianThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("守护线程运行了"+i+"次");
        }
    }
}

        创建测试类Test03

public class Test03 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        GuardianThread guardianThread = new GuardianThread();

        //将GuardianThread设置为守护线程
        guardianThread.setDaemon(true);

        //启动两个线程
        myThread.start();
        guardianThread.start();
    }
}

运行结果如下：

明显，当非守护线程结束时，守护线程也会结束，只不过告知需要时间，结束会有延迟。

        6.1.3  礼让线程

        场景说明:如果两个线程一起执行,可能会执行一会儿线程A,再执行一会线程B,或者可能线程A执行完毕了,线程B再执行.
        那么如果想让尽量让两个线程交替执行，就需要用到礼让线程
        注意：只是尽可能的平衡,不是绝对的你来我往,有可能线程A线程执行,然后礼让了,但是回头A又抢到CPU使用权了。

        创建yieldThread类

public class MyThread extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
            //调用yield方法
            Thread.yield();
        }
    }
}

        创建测试类Test04

public class Test04 {
    public static void main(String[] args) {
        yieldThread y1 = new yieldThread();
        yieldThread y2 = new yieldThread();

        y1.setName("y1线程");
        y2.setName("y2线程");

        y1.start();
        y2.start();
    }
}
        6.1.4  插入线程

        继续沿用MyThread类

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

        创建测试类Test05

public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        t1.setName("线程1");
        t1.start();

        /*
          表示把t1插入到当前线程之前,t1要插到main线程之前,所以当前线程就是main线程
         */
        t1.join();

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了......"+i);
        }
    }
}
Jaymr1031
关注
【金三银四】多线程面试题（2021最新版）
热门推荐
SQY0809的博客
04-07 2万+
目录 前言 1.多线程有什么用？ 2.线程和进程的区别是什么？ 3.Java 实现线程有哪几种方式？ 4.启动线程方法 start()和 run()有什么区别？ 5.怎么终止一个线程？如何优雅地终止线程？ 6.一个线程的生命周期有哪几种状态？它们之间如何流转的？ 7.线程中的 wait()和 sleep()方法有什么区别？ 8.多线程同步有哪几种方法？ 9.什么是死锁？如何避免死锁？ 10.多线程之间如何进行通信？ 11、线程怎样拿到返回结果？ 12、violatile 关键字的作
40 个 Java 多线程问题总结
qq_41490913的博客
05-20 149
40 个 Java 多线程问题总结
40个Java多线程问题总结
u013322876的博客
11-06 942
http://geek.csdn.net/news/detail/113211
【关于Java的多线程】
weixin_64178283的博客
08-12 1113
多线程 = 让程序“同时”执行多个任务
java中多线程常见面试题
2509_93957743的博客
10-28 299
线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。2. 将 Runnable 对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个 Runnable 对象调用外部类的这些方法。数据的分析，数据迁移的时候，可以用多线程，比如hadoop中mapreduce计算时候，可以增加分区。
java多线程的一些杂乱问题
emmmsuperdan的博客
08-10 210
         
多线程java_史上最全 Java 多线程面试题及答案
weixin_39736547的博客
11-17 193
这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍，不会去看网上的答案，因此可能有些问题讲的不对，能指正的希望大家不吝指教。1、多线程有什么用？一个可能在很多人看来很扯淡的一个...
Java多线程面试问题
小弟_liao的博客
05-07 222
1. 进程和线程之间有什么不同？ 一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。 2. 多线程编程的好处是什么？ 在多线程程序中，多个线程被并发的执行以提高程序的效率，CP...
java 网络知识 + 多线程问题
laocooon的博客
10-07 941
【代码】java 网络知识 + 多线程问题。
JAVA 多线程
weixin_70624562的博客
11-25 112
多线程是一种并发编程的技术，它允许程序同时执行多个任务，从而提高程序的性能和响应能力,也是一个强大的编程工具，可以用于并行处理计算密集型任务、提高用户界面的响应性以及优化网络和IO操作等。然而，多线程编程也复杂且容易产生问题，需要仔细设计和注意线程安全性，以避免潜在的并发问题。
java使用多线程运行集合数据
gkkljy的博客
08-09 575
1.配置线程池参数 import org.slf4j.MDC; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.Map; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; /** *
java架构师面试题——多线程&并发篇
杜引强
01-17 1174
在 Java 中典型的消息传递方式，就是 wait() 和 notify() ，或者 BlockingQueue。Entry本身是一个弱引用，他的key是指向ThreadLocal的弱引用，Entry具备了保存key value键值对。AQS实际上以双向队列的形式。1. 只有在调用线程拥有某个对象的独占锁时，才能够调用该对象的wait(),notify()和notifyAll()方。4. final变量的写happen-before于final域对象的读，happen-before后续对final变量的读。
Java面试题库——多线程
qq_58193440的博客
10-22 656
1.并行和并发有什么区别？ 并行：是指两个或多个事件在同一时刻发生，是在不同实体上的多个事件； 并发：是指两个或多个事件在同一时间间隔发生，是同一实体上的多个事件。 2.线程和进程的区别？ 根本区别：进程是资源分配的基本单位，线程是程序执行的基本单位。 资源开销：每个进程都有独立的代码和数据空间，程序之间的切换会有较大的开销；线程可以看作轻量级的进程，同一线程共享代码和数据空间，每个进程都有自己独立的运行栈和程序计数器(PC)，线程之间切换的开销小。 包含关系：如果一个进程中有多个线程，则执行过程不是一条
java基础day15 ----多线程
weixin_62189092的博客
11-11 1002
FixedThreadPool和SingleThreadExecutor 允许的请求队列长度为Integer.MAX_VALUE，可能会堆积 大量的请求，从而引起OOM异常CachedThreadPool 和newScheduledThreadPool允许创建的线程数为Integer.MAX_VALUE，可能会创 建大量的线程，从而引起OOM异常。
Java17多线程可见性详细讲解以及问题，为什么用它？
a_beiyo的博客
08-14 1334
本文探讨了Java多线程编程中的可见性问题及其解决方案。可见性指线程对共享变量的修改能否被其他线程及时看到，主要受CPU缓存架构和指令重排序影响。Java通过JMM内存模型和happens-before规则保证可见性，提供了volatile、synchronized、final和原子类等解决方案。Java17对volatile和ThreadLocal进行了优化，并引入更严格的内存模型。最佳实践包括优先使用final、合理选择同步机制和避免常见误区。理解这些原理对于编写正确的并发代码至关重要。
一款针对Spring漏洞框架进行快速利用的图形化工具
最新发布
LiBai'S BLOG
06-29 240
一款针对Spring漏洞框架进行快速利用的图形化工具。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值