Java多线程（详细最全）

最新推荐文章于 2023-02-20 01:00:17 发布
最新推荐文章于 2023-02-20 01:00:17 发布
阅读量319 收藏
点赞数
分类专栏： java编程 java 文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23587709/article/details/111678018
版权

**一.

1.程序 进程 线程**

程序：

  • 程序是指令和数据的一个有序集合，其本身没有任何运行的含义，是一个静态的概念。

进程：

  • 进程是程序执行的一个过程，它是一个动态的概念，是系统资源分配的单位。例如：我们的播放器，游戏等等

线程：

  • 线程是CPU调度和执行的单位，例如：我们程序中的main（）被称为主线程，为系统的入口，用于执行整个程序。

小结：

  1. 一个进程至少包括一个线程，不然就没有存在的意义。
    在程序运行时，即使没有创建自己的线程，后台仍然还会有很多线程，例如：main()线程，gc线程等等
  2. 在一个进程中，如果开辟了多个线程，那这些线程的运行由调度器安排调度，先后顺序不能认为干预。
  3. 对同一份资源的操作时，会存在资源抢夺的问题，这个时候就要加入并发控制。例如有100张电影票，但是同时有10000个人来抢，如果不加入并发控制，这个时候票的余额就会出现-9900。

2.如何创建一个进程

	 1. 继承Thread类 
	 2. 继承Thread类 
	 3. 重写run（）方法 
	 4. 通过< 子类对象.start（）>启动这个线程

实例：

package java_demo.多线程;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//通过多线程下载网络图片
public class Thread_download extends Thread{
    private String name;
    private String url;

    public Thread_download(String name, String url) {
        this.name = name;
        this.url = url;
    }

    public void run()
    {
        Download download = new Download();
        download.download(url,name);
        System.out.println("已经下载图片到"+name);
    }

    public static void main(String[] args) {
        Thread_download test1 = new Thread_download("test1", "https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=24336452,906724543&fm=26&gp=0.jpg");
        Thread_download test2 = new Thread_download("test2", "https://ss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=3649178992,1821853682&fm=26&gp=0.jpg");
        Thread_download test3 = new Thread_download("test3", "https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=3401732207,3726302783&fm=26&gp=0.jpg");
        test1.start();
        test2.start();
        test3.start();
    }
}
class Download{
    public void download(String url,String name)
    {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("下载器异常！！！");
        }
    }
}

	 1. 实现Runnable接口 
	 2. 实现Runnable接口 
	 3. 定义无参run（）方法 
	 4. 通过<传入目标对象+Thread对象.start（）>启动这个线程

实例：

package java_demo.多线程;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class Runnable_download implements Runnable{
    private String name;
    private String url;

    public Runnable_download(String name, String url) {
        this.name = name;
        this.url = url;
    }


    @Override
    public void run() {
        Download download = new Download();
        download.download(url,name);
        System.out.println("已经下载图片到"+name);

    }

    public static void main(String[] args) {
        Runnable_download test1 = new Runnable_download("test1", "https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=24336452,906724543&fm=26&gp=0.jpg");
        Runnable_download test2 = new Runnable_download("test2", "https://ss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=3649178992,1821853682&fm=26&gp=0.jpg");
        Runnable_download test3 = new Runnable_download("test3", "https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=3401732207,3726302783&fm=26&gp=0.jpg");
        new Thread(test1).start();
        new Thread(test2).start();
        new Thread(test3).start();

    }

}
class Downloads{
    public void download(String url,String name)
    {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("下载器异常！！！");
        }
    }
}

小结

  • 建议使用Runnable接口，因为其避免了单继承的局限性，灵活方便，方便一个对象被多个线程使用。

3.lambda表达式

优点

  1. 避免内部匿名类定义过多。
  2. 去掉了一些没有意义的代码，只留下了核心逻辑。

语法格式

  • 语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

4.静态代理模式

总结

  1. 真实的角色 代理角色（需要真实角色的引用）
  2. 共同实现一个接口

实例

package java_demo.多线程;
//静态代理模式
/*
1.真实的角色
2.代理角色
3.共同实现的接口
 */
public class Thread_proxy {
    public static void main(String[] args) {
        Weeding weeding = new Weeding(new You());
        weeding.Happymarry();
    }
}
interface Marry
{
    void Happymarry();
}

class You implements Marry
{

    @Override
    public void Happymarry() {
        System.out.println("我要结婚了，超级开心！！！");
    }
}

class Weeding implements Marry
{
    private Marry marry;

    public Weeding(Marry marry) {
        this.marry = marry;
    }

    @Override
    public void Happymarry() {
        before();
        this.marry.Happymarry();
        after();
    }
    public void before()
    {
        System.out.println("结婚之前布置现场！！");
    }
    public void after()
    {
        System.out.println("结婚之后数钱！！！");
    }

}

5.线程的生命周期

  • 初始状态：线程对象一旦创建，就进入了初始状态。
  • 就绪状态：当调用start（）方法时，线程就进入了就绪状态，但不代表立即调度执行想，需要CPU对你进行调度你才是运行状态，否则一直就是就绪状态。
  • 运行状态：被调度程序选择作为当前线程时的状态。
  • 阻塞状态：当调用sleep，wait或者同步锁时，线程进入阻塞状态，程序不往下继续执行，阻塞事件解除以后，线程重新进入就绪状态，等待调度程序调度。
  • 死亡状态：线程中断或者结束。一旦进入死亡状态，就不能再次启动。

6.线程的停止

  1. 建议使用正常停止——————>利用次数
  2. 建议使用标志位
  3. 不建议使用stop，destroy等jdk不建议使用的过时方法

实例

package java_demo.多线程;


/*
线程停止
1.建议线程正常停止——————>利用次数
2.建议使用标志位
3.不建议使用stop或destroy等过时且jdk不建议使用的方法
 */
public class Thread_stop implements Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag)
        {
            System.out.println("runTread"+i++);
        }
    }
    public void stop()
    {
        this.flag = false;
    }

    public static void main(String[] args) {
        Thread_stop thread_stop = new Thread_stop();
        new Thread(thread_stop).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("mainThread"+i);
            if (i==100)
            {
                thread_stop.stop();
                System.out.println("run线程已经停止！！！");
            }
        }
    }
}

7.线程休眠

  • 利用sleep方法让线程休眠，进入阻塞状态

实例：

package java_demo.多线程;


/*
模拟倒计时
 */
public class Thread_sleep {
    public static void main(String[] args) {
        sleep();
    }
    public static void sleep()
    {
        int num = 10;
        while (true)
        {
            System.out.println("倒计时："+num--);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (num<=0)
            {
                break;
            }
        }
    }
}

8.线程礼让

  1. 利用yield（）方法 让当前线程暂停，但是不进入阻塞状态
  2. 让线程重新回到就绪状态，等待调度程序对其进行调度
  3. 最终CPU调度全靠心情，所以礼让不一定成功。

实例：

package java_demo.多线程;

public class Thread_yield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"A").start();
        new Thread(myYield,"B").start();
    }
}

class MyYield implements Runnable
{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行！！");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束执行！！");
    }
}

9.线程强制执行（插队）
join合并线程，待此线程结束以后再执行其他线程，其他线程阻塞。
实例
package java_demo.多线程;

public class Thread_join implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("我是vip线程！！我正在执行第"+i);
        }
    }

    public static void main(String[] args) {
        Thread_join thread_join = new Thread_join();
        Thread thread = new Thread(thread_join);
        thread.start();

        for (int i = 0; i < 500; i++) {
            System.out.println("我是主线程，我正在执行！！第"+i);
            if (i == 200)
            {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.线程的优先级

  • 设置线程优先级

     对象.setpriority(int n) (0<=n<=10)

  • 获取线程优先级

     对象.getpriority(int n)

*线程优先级高并不一定代表先调度，只是说概率提高了。
实例

package java_demo.多线程;

public class Thread_priority {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"————————>"+Thread.currentThread().getPriority());
        Mypriority mypriority = new Mypriority();
        Thread thread1 = new Thread(mypriority,"a");
        Thread thread2 = new Thread(mypriority,"b");
        Thread thread3 = new Thread(mypriority,"c");
        Thread thread4 = new Thread(mypriority,"d");
        Thread thread5 = new Thread(mypriority,"e");
        thread1.start();
        thread2.setPriority(3);
        thread2.start();
        thread3.setPriority(5);
        thread3.start();
        thread4.setPriority(7);
        thread4.start();
        thread5.setPriority(10);
        thread5.start();

    }

}
class Mypriority implements Runnable
{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"————————>"+Thread.currentThread().getPriority());
    }
}

11.守护线程（Deamon）

  1. 线程分为守护线程和用户线程
  2. 虚拟机必须保证用户线程执行完毕
  3. 虚拟机不必等待保护线程执行完毕
  4. 保护线程有垃圾回收，监控内存等等机制

实例

package java_demo.多线程;
/*
守护线程
 */
public class Thread_deamon {
    public static void main(String[] args) {
        Gad gad = new Gad();
        Me me = new Me();
        Thread thread = new Thread(gad);
        thread.setDaemon(true);//false代表用户线程
        thread.start();
        new Thread(me).start();
    }
}
class Gad implements Runnable
{

    @Override
    public void run() {
        while (true)
        {
            System.out.println("上帝守护着你！！");
        }
    }
}

class Me implements Runnable
{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("开开心心活着第"+i+"年！");
        }
        System.out.println("goodbye world!!!!!!");
    }
}

12.线程同步

  • 并发：同一个对象被多个线程操作时，别叫做并发。
  • 线程同步：线程同步其实就是一种等待机制，当多个线程想要他是去操作一个对象时，它们就会进入到这个对象的等待池中形成一个队列，等上一个线程使用结束，下一个线程再使用。
    什么时候用：处理多线程问题时，当多个线程访问一个对象时，并且有的对象还想修改这个对象，这个时候我们就需要线程同步。
  • 线程同步形成条件：队列+锁

*通俗一点来讲，线程同步就像很多人排队去用一个厕所，前面的人进去以后把锁锁上，结束以后把锁打开，下一个进去把锁锁上…
优点：确保了数据在方法中被访问的正确性，安全性。
缺点：降低效率，一个线程持有锁会导致其他需要此锁的线程挂起。（鱼跟熊掌不可兼得）

13.线程池

背景

  • 经常创建和销毁使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路

  • 可以提前创建好多个线程放入线程池中，使用时直接取，使用完放入线程池，这样就避免了重复的创建和销毁，实现了重复利用。

优点

  1. 提高了响应速度，减少了创建线程的时间。
  2. 降低了资源的消耗。
  3. 便于线程管理。

实例：

package java_demo.多线程;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Thread_pool {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService server = Executors.newFixedThreadPool(10);
        Pool pool = new Pool();
        server.execute(pool);
        server.execute(pool);
        server.execute(pool);
        server.execute(pool);
        server.execute(pool);
        //关闭连接
        server.shutdown();
    }
}
class Pool implements Runnable
{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
Jeson-Sun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
主线程等待子线程结束代码
10-14
我在工作的过程中遇到一个问题,需要主线程等等所有子线程执行完后再做某件事情,在网上找了很多代码,都没有真正解决这个问题. 现在我解决了这个问题,把代码共享出来供大家参考. 代码中有注释和注意事项,相信大家看过后就会觉得非常简单.
java进阶7-多线程
godfather_001的博客
03-15 278
java进阶7-多线程意义进程与线程进程引入线程作用java程序执行原理线程的创建继承Thread实现Runnable接口线程启动线程生命周期线程的调度与控制调度模式线程优先级Thread.sleep()Thread.yield()t.join()t. interrupt（）正确停止线程线程同步一个线程一个对象守护线程设置守护线程Timer 定时器object与线程 意义 提高cpu的使用率 进程与线程 进程是一个程序，例如 qq，线程是进程任务之一 进程引入线程作用 提高进程使用率 一个线程一个栈，共享
java(七) ——多线程
java能飞翔
01-24 439
java线程的初步学习，主要是创建以及Thread的几个常用方法以及一个窗口卖票的案例
java 7.多线程
weixin_61049097的博客
05-27 215
基本概念 程序：一段静态代码 进程：正在运行的一个程序，进程可以细化为多个线程，每个线程，拥有自己独立的栈、程序计数器，多个线程共享同一个进程中的结构方法区、堆。 线程：一个程序内部的执行路径 单核CPU与多核CPU 一个java应用程序至少有3个线程，main()主线程，gc()垃圾回收线程，异常处理线程，如果发生异常会影响主线程。 并行：多个cpu执行多个任务 并发：一共cpu“同时”执行多个任务 优点：完成时间相对较短；提高应用程序的响应，对图形化界面更有意义，增强用户体验；提高.
Qt线程QThread详解
北极星的技术笔记
02-20 6143
在程序中使用线程可以提高程序的性能、并发性、响应性和稳定性，使得程序设计更加灵活和简单。但是，线程编程也有一些挑战，如线程安全性和死锁等问题需要格外注意。我们使用QT框架编程时，可以用框架提供的线程类QThread来管理线程。本文将介绍使用QThread编程时的两种方式，并给出一个数据同步的示例。在介绍QThread之前先复习下线程的定义，线程是操作系统中的基本执行单元，是一个独立的执行路径。每个线程都有自己的栈空间，用于存储本地变量和函数调用的上下文。
Qt之QThread介绍(常用接口及实现、自动释放内存、关闭窗口时停止线程运行、同步互斥)
热门推荐
yky的博客
08-09 1万+
在程序设计中，为了不影响主程序的执行，常常把耗时操作放到一个单独的线程中执行。Qt对多线程操作有着完整的支持，Qt中通过继承QThread并重写run()方法的方式实现多线程代码的编写。针对线程之间的同步与互斥问题，Qt还提供了QMutex、QReadWriteLock、QwaitCondition、QSemaphore等多个类来实现。 本篇博客将针对以下几个方面进行讲解 [1]QThread...
QThread的用法
顺其自然~专栏
07-07 8533
QThread类提供了一个与平台无关的管理线程的方法。一个QThread对象管理一个线程。QThread的执行从run()函数的执行开始，在Qt自带的QThread类中，run()函数通过调用exec()函数来启动事件循环机制，并且在线程内部处理Qt的事件。在Qt中建立线程的主要目的就是为了用线程来处理那些耗时的后台操作，从而让主界面能及时响应用户的请求操作。QThread的使用方法有如下两种：下面通过具体的方法描述和例子来介绍两种方法。 首先新建一个worker类，该类重点在于其doWork槽
多线程中的Join
柯基的博客
09-16 2542
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程程序设计详细解析
12-26
Java多线程程序设计详细解析，详细介绍了多线程的方方面面，是java备考和面试宝典
java多线程详细总结
09-04
以下小编就对java中的多线程进行了详细的总结分析，需要的朋友可以过来参考下，希望对大家有所帮助
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
Java使用递归求解斐波那契数列
qq_23587709的博客
12-06 6624
斐波那契数列：指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368…… 注意：此时我们需要注意的是该数列第一项是0，第二项是1，接下来的每一项则是前两项之和 思路：这个题我们需要用到递归的方法，首先我们需要先解决数列前两项已知的项，我们首先定义一个静态函数feibonaqie（）， 在函数当中，我们先利用一个if语句去判断前两项，如
JAVA封装
qq_23587709的博客
12-07 4266
封装：什么是封装，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。 通俗一点来说就是把类中的某些信息进行隐藏，从而使外部程序不能直接对这些信息进行直接的访问，只能通过类中定义的方法对这些隐藏的信息进行操作和访问。 目的：使其他类只能通过操控类中的对象来直接达到目的，不能看到具体的实现和属性，从而提高了程序的安全性和便利性。隐藏信息，实现便利。 封装的实现步骤： 通过访问限制符修改类中属性的可见性，从而限制对类中属性的访问。 public class
Java IO流（详细）
qq_23587709的博客
12-09 926
IO流 流：可以理解为是一个数据的序列，输入流代表从一个源读取数据，输出流表示将数据写入一个目标中。 什么是IO流：用来输出输入的流，也可以理解为IO流就是以流的方式来进行输出输入。 水源地是产水的地方（相当于是源） 自来水厂的水从哪来呢？从水源地输入。（相当于IO流中的输入流） 自来水厂的水要去哪呢？他将输出到用户手中。（相当于IO流中的输出流） 缓冲区：一个用于基本数据类型的容器。 为什么我们想要水就会有水呢？那是因为用户和自来水厂之间有一个储水池。同样Java中也有一个储水池，叫做缓冲区。
Java注解和反射（详细）
qq_23587709的博客
12-26 559
1.注解—Annotation 1.1什么是注解 注解就是源代码的元数据，通熟的讲就是代码中的标签。 1.2注解的作用 不是程序本身，但可以对程序做出解释。 可以被其他程序读取 1.3注解的格式 注解是以"@+注释名" 注解在什么地方使用 可以附加在packpackage，class，method，filed等上面，相当于给他们添加了额外的辅助信息。 2.反射 2.1动态语言和静态语言 动态语言：是一类在运行的时候能改变其结构的语言，例如新的函数，对象，甚至代码可以被引进。主要的语言有Py
什么是Java中的递归方法
qq_23587709的博客
12-06 546
递归：递归指的是在函数的定义当中调用自身函数的方法 举个例子：从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？"从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？‘从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？……’"其实递归思想就和这个故事相差不大。 语法格式如下： public void digui() { digui(); } public static void main(String args[]
JAVA接口
qq_23587709的博客
12-08 328
什么是接口： 官方语言：接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。 我的理解：它是一种特殊的类，特殊在它里面全是由全局常量和公共抽象方法组成，接口它是解决Java语言无法多继承的一种方法，但它更多的则是用来制定标准。（何为标准，标准就是类需要实现我这个接口，那就必须先实现我里面设置的某些方法） 为什么要用接口： 接口被用来描述一种抽象。 接口可以解决Java当中的多继承。
jni java多线程
最新发布
04-15
Java多线程是指在Java程序中同时执行多个线程，每个线程都是独立的执行流。Java提供了多线程编程的支持，可以通过创建Thread类的实例来创建线程，并通过调用start()方法启动线程的执行。 在JNI中使用Java多线程时，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值