多线程

最新推荐文章于 2025-12-05 17:02:52 发布
原创 最新推荐文章于 2025-12-05 17:02:52 发布 · 143 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #多线程 #编程语言

本文详细介绍了Java中创建线程的四种方法，包括继承Thread类、实现Runnable接口、实现Callable接口及使用线程池。并通过案例分析了线程安全问题，探讨了同步方法、同步代码块和Lock锁三种解决线程同步的策略。

1 创建线程
创建线程的方式总共有四种：
第一种是继承Thread类方式
第二种是实现Runnable接口方式
第三种是实现Callable接口
第四种是线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。
第一种：继承Thread类,重写run() 方法，调用start开启线程
注意，线程开启不一定立即执行，由cpu调度执行

public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run 方法线程体
        for(int i=0;i<20;i++){
            System.out.println("我在看代码————"+i);
        }
    }
    public static void main(String[] args) {
        //mian 线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 =new TestThread1();
        //调用start()方法开启线程
        testThread1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习线程--"+i);

        }
    }
}

输出：
我在学习线程--0
我在学习线程--1
我在学习线程--2
我在学习线程--3
我在学习线程--4
我在学习线程--5
我在学习线程--6
我在学习线程--7
我在学习线程--8
我在学习线程--9
我在学习线程--10
我在学习线程--11
我在学习线程--12
我在学习线程--13
我在看代码————0
我在学习线程--14
我在学习线程--15
我在看代码————1
我在学习线程--16
我在看代码————2
我在看代码————3
我在看代码————4
我在学习线程--17
我在看代码————5
我在看代码————6
我在看代码————7
我在看代码————8
我在看代码————9
我在看代码————10
我在看代码————11
我在看代码————12
我在看代码————13
我在看代码————14
我在看代码————15
我在看代码————16
我在看代码————17
我在看代码————18
我在看代码————19
我在学习线程--18
我在学习线程--19

Process finished with exit code 0

第二种：实现Runnable接口方式
步骤如下：

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
    的线程对象。
  3. 调用线程对象的start()方法来启动线程。

public class TestThread2 implements Runnable {
    @Override
    public void run() {
        //run 方法线程体
        for(int i=0;i<20;i++){
            System.out.println("我在看代码————"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable 接口的实现类对象
        TestThread2 testThread2=new TestThread2();
        //创建线程对象，通过线程对象来开启我们的线程，
       // Thread thread = new Thread(testThread2);
       // thread.start();
        //调用start()方法开启线程
      new Thread(testThread2).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习线程--"+i);

        }
    }
}
输出：
我在看代码————0
我在看代码————1
我在看代码————2
我在看代码————3
我在看代码————4
我在看代码————5
我在看代码————6
我在看代码————7
我在看代码————8
我在学习线程--0
我在学习线程--1
我在学习线程--2
我在学习线程--3
我在学习线程--4
我在学习线程--5
我在学习线程--6
我在看代码————9
我在学习线程--7
我在学习线程--8
我在学习线程--9

Process finished with exit code 0

Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。 总结:
实现Runnable接口比继承Thread类所具有的优势:

  1. 适合多个相同的程序代码的线程去共享同一个资源。
  2. 可以避免java中的单继承的局限性。
  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
  4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

2 线程安全
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，这就是线程安全问题。
我们通过一个案例，演示线程的安全问题:

//多个线程同时操作同一个对象
//买火车票多例子
public class TestThread3 implements Runnable {
    //票数
    private int ticketNums=10;
    @Override
    public void run() {
        while (true){
            if(ticketNums<=0){
                break;
            }
            try{
                Thread.sleep(200);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
         System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
        }
    }
    public static void main(String[] args) {
        TestThread3 ticket =new TestThread3();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小花").start();
        new Thread(ticket,"黄牛党").start();
    }
}

结果输出：小明–>拿到了第9票
黄牛党–>拿到了第9票
小花–>拿到了第10票
小花–>拿到了第8票
小明–>拿到了第8票
黄牛党–>拿到了第8票
小花–>拿到了第7票
小明–>拿到了第6票
黄牛党–>拿到了第5票
黄牛党–>拿到了第4票
小明–>拿到了第3票
小花–>拿到了第4票
黄牛党–>拿到了第2票
小明–>拿到了第1票
小花–>拿到了第0票
黄牛党–>拿到了第-1票

发现程序出现了两个问题:

  1. 相同的票数
  2. 不存在的票，比如0票与-1票，是不存在的。 这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

2.2线程同步
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized)来解决。
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。 那么怎么去使用呢?有三种方式完成同步操作:

  1. 同步方法 2. 同步代码块 3. 锁机制。

例子：1.同步方法
使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式: public synchronized void method(){
可能会产生线程安全问题的代码
}

public class UnsafeTicket {

        public static void main(String[] args) {
            TestLock2 testLock2 =new TestLock2();
            new Thread(testLock2).start();
            new Thread(testLock2).start();
            new Thread(testLock2).start();
        }
    }
    class TestLock2 implements Runnable{
        int ticketNums=10;
        @Override
        public  synchronized void run() {
            while (true){
                    if(ticketNums>0){
                        try{
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(ticketNums--);
                    }else {
                        break;
                    }

结果：
10
9
8
7
6
5
4
3
2
1

2.同步代码块
同步代码块: synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:synchronized (同步锁){
需要同步操作的代码块
}
同步锁: 对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

  1. 锁对象 可以是任意类型。
  2. 多个线程对象 要使用同一把锁。

代码：

public class Testlock3 {

    public static void main(String[] args) {
        TestLock1 testLock2 =new TestLock1();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock1 implements Runnable {
    int ticketNums = 10;
    Object lock = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            }

        }
    }
}

3.lock锁
lock锁机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。 Lock锁也称同步锁，加锁与释放锁方法化了，如下:
public void lock() :加同步锁。 public void unlock() :释放同步锁。
代码如下：

import java.util.concurrent.locks.ReentrantLock;
// 测试锁
public class TestLock {
    public static void main(String[] args) {


        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements Runnable{
    int ticketNums=10;
    //定义lock 锁
    private final ReentrantLock lock =new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try{
                lock.lock();//加锁
                if(ticketNums>0){
                    try{
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            }finally {
                lock.unlock();//解锁
            }
        }
    }
}

synchronized 与lock 的对比

  1. lock是显示锁（手动开启和关闭锁）synchronized 是隐式锁，出了作用域自动释放。
  2. Lock 只有代码块锁，synchronized 有代码块锁和方式锁
  3. 使用lock锁，JVM将花费较少的时间来调整线程，性能更好，并且具有更好的扩展性
  4. 优先使用顺序：
    Lock> 同步代码块>同步方法
zhangqiang180
关注
异步处理优化：多线程线程池与消息队列的选择与应用
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
12-01 169万+
本文讨论了两种常见的异步处理方式：多线程线程池和消息队列（MQ）。通过将非核心逻辑异步化，可以提升系统的性能和响应速度。多线程线程池适用于本地并发任务，适合需要快速响应的场景，但无法处理跨服务任务。消息队列则适用于分布式系统，能够解耦服务并保证任务的可靠性和顺序性，适合处理高并发和高可靠性要求的任务。文章提供了实际代码示例，帮助开发者根据业务需求选择合适的异步处理方式。
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
编程语言模型思考之异步和多线程
aloneload的博客
05-01 369
编程语言模型思考之异步和多线程 各种类型的编程语言在解决特定领域问题上具有独有的编程模型，例如异步模型和多线程模型，语言最初设计者考虑哪种模型至关重要 目的：不管哪种模型，其目的是为了程序的运行可持续性，也就是多任务执行解决方案。不能因为某些任务一直阻塞，而其资源（主要CPU）处于不工作状态，因此衡量一 个语言的优劣，大部分评论文章针对是否充分利用处理器，以及对于编程人员在该模型上编程的易用...
C语言中的多线程编程
weixin_33739541的博客
11-26 1758
#include&lt;stdio.h&gt; #define NUM 6 int main() {     void print_msg(char*);     print_msg("hello,");     print_msg("world!"); } void print_msg(char* m) {     int i;     for(i=0;i&lt;NUM;i...
多线程编程（python语言）
sunshine晗的博客
08-10 1965
     众所周知，多线程编程是一种可以提高整个任务性能的并行处理方式。多线程编程的主要特点有以下几个方面，本质上是异步的；需要多个并发活动；每个活动的处理顺序可能是不确定的，或者说是随机的、不可预测的。这种编程任务可以被组织或划分成多个执行流，其中每个执行流都有一个指定要完成的任务。根据应用的不同，这些子任务可能需要计算出中间结果，然后合并为最终的输出结果。在学习多线程的一个主要的误区就是，不要...
第四章 多线程
weixin_62008675的博客
09-10 2848
线程A正在使用sleep()暂停着: Thread.sleep(100000)，如果要取消它的等待状态,可以在正在执行的线程里(比如这里是B)调用a.interrupt()［a是线程A对应到的Thread实例］，令线程A放弃睡眠操作。线程在进入等待区,会把锁定解除,当对等待中的线程调用interrupt()时，会先重新获取锁定，再抛出异常。在获取锁定之前，是无法抛出异常的。当线程以join()等待其他线程结束时，当它被调用interrupt()，它与sleep()时一样，会马上跳到catch块里.。
C++ 多线程
m0_74896062的博客
08-21 3839
精讲了C++ 的多线程，对面试有帮助
C++多线程
weixin_43229348的博客
04-17 3470
1.基础知识 为了提高CPU的使用率，将某些需要耗时较多的任务或是大量IO操作（IO处理速度很慢），采用多线程可以适当的提高程序的执行效率。 C++11之后有了std::thread库，需要引入头文件： 先来介绍Thread的成员函数： # 用来查看当前线程的id thread::get_id() # 检查此线程是否还和主线程连接（已经完成join、detach的线程都是false） thread：：joinable() # 将线程与主线程的连接切断，并且此线程会继续独立执行下去，直到执行结束时候释放分配的
多线程编程
idpangpengcheng的博客
11-16 6453
多线程编程
Linux多线程
GG_Bruse的博客
02-13 8680
之前提到每个线程都有独占的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计管理模块，而是直接复用了进程控制块，即Linux中的所有执行流都是轻量级进程。Linux系统中不提供真正的线程ID，只提供LWP，即操作系统只需通过LWP对轻量级进程进行管理，而供用户使用的线程接口等其他数据，由线程库来管理，因此管理线程时的"先描述，再组织"就应该在线程库中完成。
Java多线程面试题
tq02的博客
07-10 2934
线程的面试点问题
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
【多线程与高并发】- 浅谈volatile
热门推荐
qq_43843951的博客
02-24 22万+
volatile是Java语言中的一种轻量级的同步机制，它可以确保共享变量的内存可见性，也就是当一个线程修改了共享变量的值时，其他线程能够立即知道这个修改。
TensorRT笔记（5）：研究timingCache
ouliten的博客
12-02 1000
在里出现了大量的timingCache，但是当时没有取研究这是干啥的，本文就来解析一下。样例都基于上面的文章。
MVP改成MVVM模式
u014035162的专栏
12-05 547
面将登录示例改造成（基于 Android Jetpack 的 ViewModel + LiveData + DataBinding），核心是抛弃 Presenter 中间层，通过 ViewModel 管理数据和业务逻辑，LiveData 实现数据驱动 UI，DataBinding 简化视图与数据的绑定。
零基础学JAVA--Day41(IO文件流+IO流原理+InputStream+OutputStream)
最新发布
Dxxyyyy的博客
12-05 551
文件在程序中是以流的形式来操作的流：数据在数据源（文件）和程序（内存）之间经历的路径输入流：数据从数据源（文件）到程序（内存）的路径输出流：数据从程序（内存）到数据源（文件）的路径。
QT多线程编程示例详解
标题“QT的多线程编程示例”指的是关于使用QT（一种跨平台的C++图形用户界面应用程序开发框架）进行多线程编程的示例。多线程是编程中一种技术，允许一个程序同时执行两个或两个以上的部分，这些部分可以并行运行，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值