线程的创建！收藏起来

已于 2024-07-16 10:38:15 修改
阅读量111 收藏 1
点赞数 1
文章标签： java jvm 开发语言
于 2024-07-10 21:21:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72156649/article/details/140317188
版权

1.  什么是线程

线程。又称轻量级进程。线程是进程中的一条执行路径，也是CPU的基本调单位。

若一个程序可同一时间执行多个线程，就是支持多线程的。

一个进程由一个或多个线程组成，彼此间完成不同的工作，同时执行，称为多线程。

为什么使用多线程 

 充分利用cpu，提高程序的效率

2.  java如何实现多线程 

提供了三种实现多线程的方式：

  • 继承Thread类
  • 实现Runnable接口
  • 实现Callable接口

 2.1  继承Thread类

语法：

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int a=0;a<20;a++){
            //getName 获取线程名，默认的名称Thread-n，该方法必须在Thread类下才能使用
            //Thread.currentThread():获取当前正在执行的线程对象
            System.out.println(Thread.currentThread().getName()+"-------------------"+a);
        }
    }
}
public class TestT01 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int a=0;a<20;a++){
            System.out.println(Thread.currentThread().getName()+"-------------------"+a);
        }
    }
}

 案例

public class SellTictet01 extends MyThread {
    private int tictets = 20;

    @Override
    public void run() {
        while (true) {
            if (tictets > 0) {
                tictets--;
                System.out.println(Thread.currentThread().getName() + "买了一张票，剩余" + tictets + "张");
            } else {
                System.out.println(Thread.currentThread().getName() + "卖完了");
                break;
            }
        }
    }
}
public class Stest01 {
    public static void main(String[] args) {
        SellTictet01 sellTictet1 = new SellTictet01();
        SellTictet01 sellTictet2 = new SellTictet01();
        SellTictet01 sellTictet3 = new SellTictet01();
        SellTictet01 sellTictet4 = new SellTictet01();
        Thread thread1 = new Thread(sellTictet1);
        Thread thread2 = new Thread(sellTictet2);
        Thread thread3 = new Thread(sellTictet3);
        Thread thread4 = new Thread(sellTictet4);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

2.2  实现Runnable接口

public class Myrunnable implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"===="+i);
        }
    }
}
public class TestR01 {
    public static void main(String[] args) {
        Myrunnable myrunnable = new Myrunnable();
        Thread thread = new Thread(myrunnable);
        thread.start();
        for (int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"===="+i);
        }
    }
}

 案例

public class SellTictet02 implements Runnable{
    private int tict=100;
    @Override
    public void run() {
        while (true) {
            if (tict > 0) {
                try {
                    //睡眠
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                tict--;
                System.out.println(Thread.currentThread().getName() + "卖了一张票，剩余" + tict + "张");
            } else {
                break;
            }
        }
    }
}
public class Rtest01 {
    public static void main(String[] args) {
        SellTictet02 sellTictet = new SellTictet02();
        Thread thread1 = new Thread(sellTictet, "窗口A");
        Thread thread2 = new Thread(sellTictet, "窗口B");
        Thread thread3 = new Thread(sellTictet, "窗口C");
        Thread thread4 = new Thread(sellTictet, "窗口D");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

 分析出超卖和重卖现象。这是因为多个线程共享一个资源，导致线程安全隐患问题，后期解决线程安全问题。后期我们可以使用锁解决

两种方式继承Thread和实现Runnnable 哪种方式比较好

使用第二种，第二种的扩展性更好。

2.3  实现Callable接口 

public class MyCallable implements Callable {
    //1到100的和
    @Override
    public Object call() throws Exception {
        double sum=0;
        for (int i=0;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}
public class TestC01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask task = new FutureTask(myCallable);
        Thread thread = new Thread(task);
        thread.start();
        Object o = task.get();
        System.out.println(o);
    }
}

 3.Thread类中常用的一些方法

3.1 线程休眠方法-static void sleep

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int a=0;a<20;a++){
            try {
                //休眠十毫秒
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-------------------"+a);
        }
    }
}

3.2  yield 当前线程让出cpu-参与下次的竞争

3, 

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int a=0;a<20;a++){
            //当前线程让出CPU参与下次竞争
            //使用yield线程出现交换执行的频率高了。
           Thread.yield();
            System.out.println(Thread.currentThread().getName()+"-------------------"+a);
        }
    }
}

3.3  join加入当前线程上

插入的线程执行完毕主线程才会执行

public class TestT01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("线程A");
        MyThread t2 = new MyThread();
        t2.setName("线程B");
        t1.start();
        t2.start();
        t1.join();
        //t1加入主线程上，主线程需要等t1执行完毕后才会执行。
        for (int a=0;a<20;a++){
            System.out.println(Thread.currentThread().getName()+"-------------------"+a);
        }
    }
}

 3.4  setDaemon()设置线程为守护线程

当所有线程执行完毕后，守护线程也会终止

public class TestT01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("线程A");
        t1.setDaemon(true);
        t1.start();
        for (int a=0;a<20;a++){
            System.out.println(Thread.currentThread().getName()+"-------------------"+a);
        }
    }
}

 JDK--默认就要有一个守护线程，GC垃圾回收

4.  解决线程安全问题 

4.1  什么情况下会出现线程安全问题

当多个线程操作同一个资源时，则出现线程安全问题。

4.2  java如何解决线程安全问题 

提高了两种方法：第一种：使用synchronized自动锁

                             第二种：使用Lock手动锁

使用锁相当于把原来的异步转化为同步操作

使用synchronized关键字解决

synchronized(共享锁对象){
   同步代码块

}

解决超卖现象 

public class SellTictet02 implements Runnable {
    private int tict = 1000;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (tict > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    tict--;
                    System.out.println(Thread.currentThread().getName() + "卖了一张票，剩余" + tict + "张");
                } else {
                    break;
                }
            }
        }
    }
}

 使用Lock手动

public class SellTictet02 implements Runnable {
    private int tict = 1000;
    private Lock l = new ReentrantLock();

    @Override
    public void run() {
        while (true)
            try {
                //加锁
                l.lock();
                if (tict > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    tict--;
                    System.out.println(Thread.currentThread().getName() + "卖了一张票，剩余" + tict + "张");
                } else {
                    break;
                }
            }finally {
                //解锁
                l.unlock();
            }
    }
}

在这有一个问题(synchronized和Lock都有这个问题)，如果执行卖一百张票，只有先开启的线程再卖， 但卖一千张，甚至一万张，四个线程才能交替执行，根据ai的回答是因为这个，我也不知道，大家姑且看一下：

 

synchronized和Lock 的区别

syn可以使用代码块和方法。自动加锁和释放锁。不会出现死锁问题。

lock它只能使用在代码块中。需要手动加锁和释放锁。如果不释放锁，死锁问题。灵活。它的释放锁必须放在finally

5.  死锁 

线程A拥有资源a，希望获得资源b，线程B拥有资源b，希望获得资源a。两个线程互相拥有对方希望获得的锁资源。可能会出现程序堵塞，从而造成死锁。

public class locka implements Runnable{
    @Override
    public void run() {
        synchronized ("locka"){
            System.out.println(Thread.currentThread().getName()+"拥有了锁a");
            synchronized ("lockb"){
                System.out.println(Thread.currentThread().getName()+"拥有了锁b");
                System.out.println(Thread.currentThread().getName()+"拥有了锁a和b");
            }
        }

    }
}

public class lockb implements Runnable{
    @Override
    public void run() {
        synchronized ("lockb"){
            System.out.println(Thread.currentThread().getName()+"拥有了锁b");
            synchronized ("locka"){
                System.out.println(Thread.currentThread().getName()+"拥有了锁a");
                System.out.println(Thread.currentThread().getName()+"拥有了锁b和锁a");
            }
        }
    }
}

public class test {
    public static void main(String[] args) {
        locka a = new locka();
        lockb b = new lockb();
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(b);
        t1.setName("线程a");
        t2.setName("线程b");
        t1.start();
        t2.start();
    }
}

解决：

  1. 不要使用锁嵌套。
  2. 设置超过时间。 --Lock类中tryLock。

  3. 使用安全java.util.concurrent下的类

 6.  线程通信

wait方法和notify方法。

public class Mybank {
    //余额
    private double balance;
    //状态 true 有钱 false 没钱
    private boolean flag;
    //银行存钱
    public synchronized void cun(double money){
        if (flag==true){
            try {
                //进入等待队列，并且释放拥有的锁
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //存钱
        balance += money;
        flag = true;
        //唤醒等等待队列中的某个线程
        notify();
        System.out.println(Thread.currentThread().getName()+"存钱成功，余额为："+balance);
    }
    //银行取钱
    public synchronized void qu(double money){
        if (flag==false){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balance-=money;
        flag = false;
        notify();
        System.out.println(Thread.currentThread().getName()+"取钱成功，余额为："+balance);
    }
}

//实现存钱
public class Cuntread extends Thread{
    private Mybank mybank;
    public Cuntread(Mybank mybank){
        this.mybank=mybank;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            mybank.cun(1000);
        }
    }
}

//实现取钱
public class Qutread extends Thread {
    private Mybank mybank;

    public Qutread(Mybank mybank) {
        this.mybank = mybank;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            mybank.qu(1000);
        }
    }
}

//测试
public class test {
    public static void main(String[] args) {
        Mybank mybank = new Mybank();
        Cuntread cuntread = new Cuntread(mybank);
        cuntread.setName("我");
        Qutread qutread = new Qutread(mybank);
        qutread.setName("你");
        cuntread.start();
        qutread.start();
    }
}

7.线程状态 

NEW                                        新建状态

RUNNABLE                             就绪状态和运行状态

BLOCKED                                堵塞状态

WATTING                                 等待状态

TIMED_WATTING                    时间等待

TERMINATED                          终止

通过调用不同的方法相互转换 

白七不七
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二、线程的创建
lhlyzh的博客
08-02 276
一、创建方式 线程的创建有三种方式： 继承Thread类 实现Runnable接口 实现Callable接口 注：线程开启不一定立即执行，由CPU调度决定 1. 继承Thread类 继承Thread类创建线程可分为以下几步： 自定义线程类继承Thread类 重写run() 方法，编写线程执行体 创建线程对象，调用start()方法启动线程 例： public class TestThread extends Thread { @Override public void run()
线程的基本创建
weixin_45913226的博客
04-28 233
一、创建线程方式一：继承Thread类，重写run()方法，调用start开启线程，然后JVM会执行run（）方法 public class TestThread1 extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i < 200; i++) { System.out.println("我在看代码。。。"); }
【Linux C | 多线程编程】线程的创建、线程ID、线程属性
wkd_007的博客
03-22 2405
本文介绍了线程创建相关的内容，包括pthread_create函数的详细介绍和使用例子，然后依次介绍该函数第一个参数相关的线程ID知识以及第二个参数相关的线程属性知识。读完完整地了解线程的创建。
线程创建的4种方式
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
08-03 5262
在Java中，创建线程是并发编程的基础。Java提供了多种方式来创建线程，每种方式都有其适用场景和优缺点。
Java零基础之多线程篇：线程的多种创建方式
喵手的博客
06-19 909
众所周知，多线程是现代计算机应用程序设计中的重要概念之一，尤其是在项目开发中，经常有场景会被使用到。其实它非常容易理解，它允许程序同时执行多个任务，从而提高了系统的资源利用率和响应速度。在本文中，我们将深入研究多线程的概念、本质、作用以及多种创建方式，并通过具体的Java代码测试用例来加深对多线程的理解。本文通过对多线程的概念进行介绍，我会解释多线程在现代计算机应用程序中的作用和优势。然后，我们比较了使用Runnable接口和Thread类来创建线程的两种方式，并分析了它们之间的区别。
享受自定义收藏的乐趣！
04-09
标题“享受自定义收藏的乐趣！”暗示我们将探讨如何利用自定义集合来增强编程体验。 自定义集合通常涉及到继承自.NET提供的基础集合接口，如`IEnumerable<T>`和`IDictionary, TValue>`。`IEnumerable<T>`代表一个...
jmf.zip_Mine!
09-24
- **多线程编程**: 由于媒体处理通常涉及到实时性和多线程，所以理解Java的并发编程概念非常重要。 - **扩展JMF**: 如果需要支持新的媒体格式或设备，可以编写自定义的Plug-In来扩展JMF。 通过"jmf.zip_Mine!"中的...
易语言QQ书签收藏
07-19
在本例中，"进入采集线程"可能是指启动一个专门用于获取QQ书签数据的线程，而"开始收藏线程"则可能是启动另一个线程来处理和存储这些书签。这样的设计可以避免因为网络延迟或数据处理时间过长而阻塞主程序。 "随机...
java多线程、并发及线程池介绍收藏的几篇文档
06-06
- 线程池可以预先创建一定数量的线程，处理多个任务，避免了频繁创建和销毁线程的性能损耗。 - `ThreadPoolExecutor`的构造函数接受核心线程数、最大线程数、线程空闲时间、线程队列等参数，可以根据系统需求进行...
JAVA进阶补充
2301_80150315的博客
08-15 770
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 556
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1033
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 338
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 568
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
旅游网站
weixin_43213064的博客
08-16 624
【代码】springboot旅游网站
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 986
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 735
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 283
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 1072
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
qthread两个线程
07-27
总结起来，子类化QThread的方法适用于只需要执行一个任务的线程，而使用moveToThread方法适用于需要执行多个不同任务的线程。\[1\] 参考资料： \[1\] 引用\[1\]中的内容 #### 引用[.reference_title] - *1* *2* *3*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值