线程2 Thread

已于 2023-02-01 21:06:27 修改
阅读量57 收藏
点赞数
文章标签： java Powered by 金山文档
于 2023-01-31 22:40:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42220004/article/details/128809374
版权

线程

匿名内部类的方式实现线程创建和启动
public class ThreadNoNameTest {
    public static void main(String[] args) {
//        Thread t1 = new Thread(){
//            @Override
//            public void run(){
//                System.out.println("在吗？");
//            }
//        };
//        t1.start();
        //优化
        new Thread() {
            @Override
            public void run() {
                System.out.println("在吗？");
            }
        }.start();
        //


//        Runnable ra = new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("不在");
//            }
//        };
//        Thread t2 = new Thread(ra);
//        t2.start();
//优化：
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("不在");
            }
        }).start();
        //java8开始支持lambda表达式：
        Runnable ra = ()-> System.out.println("不在");
        new Thread(ra).start();
        //再次进化哈
        new Thread(()-> System.out.println("不在")).start();
    }
}
线程的生命周期

线程调度器 调用就绪的线程

sleep（） 阻塞状态

继承方式管理线程编号和名称
public class ThreadIdNameTest extends Thread{
    public ThreadIdNameTest(String s) {
        super(s);
    }

    @Override
    public  void run(){
        System.out.println("子线程的编号："+getId()+getName());
    setName("张飞");
        System.out.println(" 修改后子线程的编号："+getId()+getName());
    }

    public static void main(String[] args) {
        ThreadIdNameTest tint = new ThreadIdNameTest("关羽");
        tint.start();
        System.out.println("主线成编号"+ tint.getId());
    }
}
守护线程

当子线程是守护线程时，当主线程结束后，则子线程随之结束

public class ThreadDaemonTest extends Thread{
    @Override
    public  void run(){
        System.out.println(isDaemon());
        for (int i = 0;i < 50;i++){
            System.out.println("子线程中：i = "+ i);
        }
    }
    //当子线程不是守护线程时，虽然主线程先结束了，
    //但是子线程依然会继续执行，直到打印完毕所有数据为止
    public static void main(String[] args) {
        ThreadDaemonTest tdt = new ThreadDaemonTest();
        //必须在线程启动之前 设置子线程为守护线程
        tdt.setDaemon(true);
        tdt.start();
        for (int i = 0;i < 50;i++){
            System.out.println("主线程中：i = "+ i);
        }
    }
}
多个线程执行不同的代码
public class SubThread1 extends Thread{
    @Override
    public void run(){
        for (int i = 1;i<=100;i+=2){
            System.out.println("子线程一中: i = "+i);
        }
    }
}
public class SubThread2 extends Thread{
    @Override
    public void run(){
        for (int i = 1;i<=100;i+=2){
            System.out.println("子线程二中: i = "+i);
        }
    }
}
public class SubThreadTest {
    public static void main(String[] args) {
        SubThread1 st1 = new SubThread1();
        SubThread2 st2 = new SubThread2();
        st1.start();
        st2.start();
        System.out.println("主线程开始等待..");
        try {
            st1.join();
            st2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println("主线程等待结束..");
    }
}
public class SubRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 1;i<=100;i+=2) {
            System.out.println("子线程一中: i = " + i);
        }
    }
}
public class SubRunnable2 implements Runnable{
    @Override
    public void run() {
        for (int i = 1;i<=100;i+=2) {
            System.out.println("子线二中: i = " + i);
        }
    }
}
public class SubRunnableTest {
    public static void main(String[] args) {
        SubRunnable sr1 = new SubRunnable();
        SubRunnable2 sr2 = new SubRunnable2();
        Thread thread = new Thread(sr1);
        Thread thread1 = new Thread(sr2);
        thread.start();
        thread1.start();
        try {
            thread.join();
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

synchronized

private Demo dm = new Demo();
@Override
    public void run() {
        synchronized (dm) {
            //模拟从后台查询余额
            int temp = getBalance();

            //模拟取款
            if (temp >=200){
                System.out.println("正在出钞，请稍后...");
                temp -= 200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                System.out.println("请核对您的账户余额");
            }
            //模拟将最新的账户余额写入到后台
            setBalance(temp);
        }
    }

线程同步机制（重点）

基本概念

当多个线程同时访问同一种共享资源时，可能会造成数据的覆盖等不一致性问题，此时就需要对线

程之间进行通信和协调，该机制就叫做线程的同步机制。

多个线程并发读写同一个临界资源时会发生线程并发安全问题。

异步操作:多线程并发的操作，各自独立运行。

同步操作:多线程串行的操作，先后执行的顺序。

解决方案

由程序结果可知：当两个线程同时对同一个账户进行取款时，导致最终的账户余额不合理。

引发原因：线程一执行取款时还没来得及将取款后的余额写入后台，线程二就已经开始取款。

解决方案：让线程一执行完毕取款操作后，再让线程二执行即可，将线程的并发操作改为串行操

作。

经验分享：在以后的开发尽量减少串行操作的范围，从而提高效率。

实现方式

在Java语言中使用synchronized关键字来实现同步/对象锁机制从而保证线程执行的原子性，具体

方式如下：使用同步代码块的方式实现部分代码的锁定，格式如下：

synchronized(类类型的引用) {

编写所有需要锁定的代码；

}

使用同步方法的方式实现所有代码的锁定。

直接使用synchronized关键字来修饰整个方法即可

该方式等价于:

synchronized(this) { 整个方法体的代码 }

线程的通信
public class ThreadCommunicateTest implements Runnable {
    private int cnt = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                // 每当有一个线程进来后先大喊一声，调用notify方法
                notify();
                if (cnt <= 100) {
                    System.out.println("线程" + Thread.currentThread().getName() + "中：cnt = " + cnt);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    cnt++;
                    // 当前线程打印完毕一个整数后，为了防止继续打印下一个数据，则调用wait方法
                    try {
                        wait(); // 当前线程进入阻塞状态，自动释放对象锁，必须在锁定的代码中调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {

        ThreadCommunicateTest tct = new ThreadCommunicateTest();
        Thread t1 = new Thread(tct);
        t1.start();

        Thread t2 = new Thread(tct);
        t2.start();
    }
}
生产者消费者模型的实现
public class ComsumerThread extends Thread{
    private  StoreHouse storeHouse;//声明一个仓库类型的引用作为成员变量 是为了能够调用仓库类中的生产方法
    //合成复用原则
    //为了确保两个线程共用同一个仓库
    public ComsumerThread(StoreHouse storeHouse){
        this.storeHouse = storeHouse;
    }
    @Override
    public void run(){
        while (true){
            storeHouse.consumerProduct();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ProduceThread extends Thread{
    private  StoreHouse storeHouse;//声明一个仓库类型的引用作为成员变量 是为了能够调用仓库类中的生产方法
    //合成复用原则
    //为了确保两个线程共用同一个仓库
    public ProduceThread(StoreHouse storeHouse){
        this.storeHouse = storeHouse;
    }
    @Override
    public void run(){
        while (true){
            storeHouse.produceProduct();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class StoreHouse {
    private  int cnt = 0;

    public synchronized void produceProduct() {
        notify();
        if (cnt<10){
            System.out.println("线程"+Thread.currentThread().getName()+"正在生产第"+(cnt+1)+"个产品");
            cnt++;
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumerProduct() {
        notify();
        if (cnt >0){
            System.out.println("线程"+Thread.currentThread().getName()+"消费第"+cnt+"个产品");
            cnt--;

        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class StoreHouseTest {
    public static void main(String[] args) {
        StoreHouse storeHouse = new StoreHouse();
        ComsumerThread t2 = new ComsumerThread(storeHouse);
        ProduceThread t1 = new ProduceThread(storeHouse);
        t1.start();
        t2.start();
    }
}
创建和启动线程的方式三
线程池（熟悉）
实现Callable接口

从Java5开始新增加创建线程的第三种方式为实现java.util.concurrent.Callable接口。

FutureTask类

java.util.concurrent.FutureTask类用于描述可取消的异步计算，该类提供了Future接口的基本实

现，包括启动和取消计算、查询计算是否完成以及检索计算结果的方法，也可以用于获取方法调用

后的返回结果。

线程池的由来

在服务器编程模型的原理，每一个客户端连接用一个单独的线程为之服务，当与客户端的会话结束

时，线程也就结束了，即每来一个客户端连接，服务器端就要创建一个新线程。

如果访问服务器的客户端很多，那么服务器要不断地创建和销毁线程，这将严重影响服务器的性

能。

（4）概念和原理

线程池的概念：首先创建一些线程，它们的集合称为线程池，当服务器接受到一个客户请求后，就

从线程池中取出一个空闲的线程为之服务，服务完后不关闭该线程，而是将该线程还回到线程池

中。

在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务

后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，任务是提交给整个线程

池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务

相关类和方法

从Java5开始提供了线程池的相关类和接口：java.util.concurrent.Executors类和

java.util.concurrent.ExecutorService接口。

public class ThreadPoolTest {

    public static void main(String[] args) {

        // 1.创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        // 2.向线程池中布置任务
        executorService.submit(new ThreadCallableTest());
        // 3.关闭线程池
        executorService.shutdown();
    }
}

carpe diem 、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c#线程Thread示例
09-04
C#线程Thread示例 C#作为一门支持多线程的语言，线程的使用是非常常见的。在.NET中，线程的知识虽然不太常被讨论，但是关于线程的知识点还是需要被关注的。本文主要介绍了C#线程Thread示例，包括线程的基本操作、...
java Thread 多线程
09-05
总之，Java中的多线程通过Thread类和Runnable接口实现，通过`synchronized`关键字确保线程安全，利用`wait()`, `notify()`, 和 `notifyAll()`进行线程间通信，有效地提高了程序的并发性能和资源利用率。在编写多线程...
ThreadX学习（2）——线程
weixin_43739110的博客
06-11 4230
ThreadX学习（2）——线程学习参考：ThreadX中的线程线程创建堆栈分配互斥锁线程优先级优先级反转优先级继承抢占阈值线程状态数据结构TCB就绪列表API 学习参考： 《Real-Time Embedded Multithreading: Using ThreadX and ARM》 安富莱_STM32-V7开发板ThreadX内核教程（V0.7） ThreadX中的线程 在ThreadX中，一般没有进程的概念，统称为线程。 关于调度器的实现细节，ThreadX可能是用汇编写的，没看懂。 T
Thread 线程关闭
afufufufu的博客
04-01 4517
Thread线程 线程对象属于一次性消耗品，一般线程执行完run方法之后，线程就正常结束了，线程结束之后就报废了，不能再次start，只能新建一个线程对象。但有时run方法是永远不会结束的。例如在程序中使用线程进行Socket监听请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。当需要结束线程时，如何退出线程呢？ 结束Thread线程的几种方法 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止 使用interrupt()方法中断线程 使用
C++ thread线程函数返回值
Keivin
03-13 6341
int f2(double p ,double& nn,int& n,int& bb) { int test = 3; for (int i = 0; i < 5; ++i) { std::cout << "Thread 2 executing\n"; //std::this_thread::sleep_for(std::chrono::milliseconds(10)); } bb = test; return bb; } std::.
C++11 多线程（std::thread）详解
热门推荐
jcShan709的博客
07-17 10万+
注：此教程以 Visual Studio 2019 Version 16.10.3 （MSVC 19.29.30038.1) 为标准 文章目录线程？进程？多线程？什么是多线程？进程与线程的区别C++11的std::threadstd::thread常用成员函数构造&析构函数常用成员函数举个栗子例一：thread的基本使用例二：thread执行有参数的函数例三：thread执行带有引用参数的函数注意事项（剩下的内容还没写完，明天再更） 线程？进程？多线程？ 什么是多线程？ 百度百科中的解释： 多.
c++线程thread教程
性感的小君君
03-16 5452
c++线程thread C++11/C++14 线程教程 thread类官网详解 thread类官网详解 参考链接 文章目录c++线程thread1.创建线程2.守护线程3. 可调用对象4. 传参5. 线程的移动和复制6.线程id7. 互斥mutex 1.创建线程 直接初始话thread类对象进行创建线程，创建线程后调用join()方法，让主线程等待子线程完成工程。 #include <iostream> #include <thread> void thread_func
【多线程】Thread类
程序猿教你打篮球的博客
04-17 6350
本期主要讲解： 1.Java 中如何进行多线程编程? 2.简单使用多线程 3.start和run的区别 4. jconsole 工具 5.Java中创建线程的写法 6.Thread类方法介绍 6.1构造方法 6.2 Thread类常见属性 6.3什么是守护线程? 6.5什么情况线程才是存活的? 6.6什么是线程中断?
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
java创建线程（Thread）的5种方式
weixin_43824267的博客
01-16 4万+
java创建线程（Thread）的4种方式方式一：继承于Thread类方式二：实现Runnable接口方式三：实现Callable接口方式四：使用线程池 方式一：继承于Thread类 步骤： 1.创建一个继承于Thread类的子类 2.重写Thread类的run() --> 将此线程执行的操作声明在run()中 3.创建Thread类的子类的对象 4.通过此对象调用start()执行线程 示例代码（遍历100以内的所有的偶数）： package atguigu.java; //1.创建一个继承于
C++11多线程: thread创建线程的三种方式
qq_42147969的博客
06-29 8703
C++11 多线程相关的头文件 <thread>：该头文件用于线程操作，主要声明了 std::thread 类，另外 std::this_thread 命名空间也在该头文件中，包含一些线程的操作函数。 <mutex>：该头文件用于互斥量操作，主要声明了与互斥量相关的类，包括 std::mutex 系列类，std::lock_guard，std::unique_lock，以及其他的类型和函数。 <condition_variable>：该头文件用于条件变量操作，主要声明了
异步多线程之Thread详解
菜鸟厚非
11-11 9150
异步多线程版本 在 .NET中随着时间的发展，线程是有许多个版本的1.0 Thread、2.0TthreadPool、3.0 Task、4.0 Parallel 等，今天我就一一进行讲解。 1.0 时代 在1.0 时代C# 就考虑到了多线程，于是就设计了 Thread 其实现在都不会再用了，除非在维护老的项目已经用了的。Thread 也是比较鸡肋的，有很多缺陷，但也并不是一无是处。 首先看 Thread 的构造函数，ThreadStart 无参数类型的委托、ParameterizedThreadStart
多线程thread
11-06
多线程thread多线程thread多线程thread多线程thread多线程thread
Thread实现多线程
05-01
继承Thread类： 1必须重写run 方法：里面放置的实际的线程体 2 启动线程： 3创建Thread对象 4调用Thread对象的start 方法启动线程
C#多线程之Thread类详解
08-29
C#多线程之Thread类详解 C#多线程编程中，Thread类是最基本也是最重要的类之一，用于创建和控制线程。在本篇文章中，我们将详细介绍Thread类的使用和实现原理。 一、Thread类概述 Thread类是System.Threading命名...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 154
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 975
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 92
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 523
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java多线程实现：从Thread到ExecutorService
2. **实现Runnable接口**：相比继承Thread类，实现Runnable接口更为灵活，因为Java不支持多重继承。只需创建一个实现了Runnable接口的类，重写`run()`方法，并将Runnable对象传递给Thread类的构造器来创建线程。这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值