JAVA之多线程

最新推荐文章于 2024-08-30 18:40:43 发布
最新推荐文章于 2024-08-30 18:40:43 发布
阅读量77 收藏
点赞数
分类专栏： Java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45116578/article/details/118914949
版权

程序、进程和线程

程序：指为了完成特定任务用某种语言编写的一组指令的集合。简单说，就是一段静态的代码。
进程：指程序的一次执行过程，是正在运行的一段程序，是一个动态的过程。
线程：一个程序内部的一条执行路径。进程可以细化为线程。

线程的创建

Thread类

  • 每个线程都是通过某个特定Thread类的对象的run()方法来完成操作。
  • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。

继承Thread类

  1. 定义子类继承Thread类；
  2. 子类中重写Thread类中的run方法；
  3. 创建Thread子类对象，即创建了线程对象；
  4. 调用线程对象start方法：启动线程，调用run方法。

启动多线程必须调用start 方法，一个线程对象只能调用一次start()方法。只是通过手动调用run方法，并没有启动多线程模式。

//使用两个线程分别输出10以内的数字
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":  "+ i );
        }
    }
}

public class ThreadsTest {

    public static void main(String[] args) {

        MyThread thread1 = new MyThread();
        thread1.setName("Thread1");
        thread1.start();

        MyThread thread2 = new MyThread();
        thread2.setName("Thread2");
        thread2.start();
        
    }
}

实现Runnable接口

  1. 定义子类，实现Runnable接口；
  2. 子类中重写Runnable接口中的run 方法；
  3. 通过Thread类含参构造器创建线程对象；
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中；
  5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

避免了单继承的局限性。且多个线程可以共享一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

//用两个线程分别输出10以内的数
class MyThread1 implements Runnable{

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

public class RunnableTest {
    
    public static void main(String[] args) {
        
        MyThread1 thread1 = new MyThread1();
        Thread t1 = new Thread(thread1);
        t1.start();

        MyThread1 thread2 = new MyThread1();
        Thread t2 = new Thread(thread2);
        t2.start();
    }
    
}

实现Callable接口

  1. 创建一个实现Callable的实现类；
  2. 实现call方法，将此线程需要执行的操作声明在call()中；
  3. 创建Callable接口实现类的对象；
  4. 将此Callable接口实现类的对象作为参数传递到FutureTask 构造器中，创建FutureTask对象；
  5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()；
  6. 获取Callable中call方法的返回值。
//用两个线程分别输出10以内的数
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class Ticket6 implements Callable{
    
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":  " + i);
        }
        return null;
    }
}

public class TicketTest7 {
    public static void main(String[] args) {
        Ticket6 c1 = new Ticket6();
        FutureTask f1 = new FutureTask(c1);
        Thread t1 = new Thread(f1);
        t1.setName("窗口1");
        t1.start();

        Ticket6 c2 = new Ticket6();
        FutureTask f2 = new FutureTask(c2);
        Thread t2 = new Thread(f2);
        t2.setName("窗口2");
        t2.start();
    }
}

相比于run()方法，可以有返回值，可以抛出异常，支持泛型的返回值。

线程池

  1. 提供指定线程数量的线程池；
  2. 执行指定的线程的操作。需要提供实现Runnable接口或者Callable接口实现类的对象；
  3. 关闭连接池。

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

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

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

public class ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(15);
        
        service.execute(new Number());
        service.execute(new Number1());

        service.shutdown();
    }
}

减少了创建新线程的时间，提高了响应速度；
重复利用线程池中的线程，不需要每次都创建，降低了资源消耗；
便于线程管理。

线程的生命周期

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没分配到CPU资源。

运行：当就绪的线程被调度并获取CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能。

阻塞：在某种特殊情况下，被认为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。

死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。

线程生命周期转换图

在这里插入图片描述

线程的同步

线程安全问题：多个线程执行的不确定性引起的执行结果的不稳定，有可能造成数据破坏。
以买票窗口为例，以下代码为不安全示例：(使用继承Thread的方式来创建线程)

class Ticket extends Thread{

    private static int ticket = 100;
    @Override
    public void run() {

        while(true) {
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":  " + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
    
}

public class TicketTest1 {
    public static void main(String[] args) {
        Ticket t1 = new Ticket();
        Ticket t2 = new Ticket();
        Ticket t3 = new Ticket();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

解决方案：

  1. 同步代码块
synchronized(对象){
//需要被同步的代码块;
}

使用同步代码块解决继承Thread类的方式的线程安全问题：使用当前类充当同步监视器。

class Ticket1 extends Thread {
    private static int ticket = 100;
    @Override
    public void run() {
        while(true) {

            synchronized (Ticket1.class){
                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":  " + ticket);

                    ticket--;
                }else{
                    break;
                }
            }

        }

    }
}

public class TicketTest2 {
    public static void main(String[] args) {
    Ticket1 t1 = new Ticket1();
    Ticket1 t2 = new Ticket1();
    Ticket1 t3 = new Ticket1();

    t1.setName("窗口1");
    t2.setName("窗口2");
    t3.setName("窗口3");

    t1.start();
    t2.start();
    t3.start();
    }
}

使用同步代码块解决实现Runnable接口创建多线程方式的线程安全问题：使用this充当同步监视器。

class Ticket2 implements Runnable{

    private static int ticket = 100;

    @Override
    public void run() {
        while(true){

            synchronized(this){

                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + ": " + ticket);
                    ticket--;
                }else {
                    break;
                }

            }
        }
    }
}

public class TicketTest3 {
    public static void main(String[] args) {
        Ticket2 r = new Ticket2();

        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  1. 同步方法
public synchronized void show(String name){
	...
}

使用同步方法解决继承Thread类的方式中的安全问题：加static关键字，使得同步监视器统一。

class Ticket3 extends Thread{

    private static int ticket = 100;

    @Override
    public void run() {

        while(true){
            show();
        }
    }

    public static synchronized  void  show(){
        if(ticket > 0){
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ": " + ticket);
            ticket--;
        }
    }
}

public class TicketTest4 {
    public static void main(String[] args) {
        Ticket3 t1 = new Ticket3();
        Ticket3 t2 = new Ticket3();
        Ticket3 t3 = new Ticket3();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

使用同步方法解决实现Runnable接口创建线程的安全问题：使用synchronized方法。

class Ticket4 implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {

        while(true){
            show();
        }

    }

    public synchronized void show(){
        if(ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":  " + ticket);
            ticket--;
        }
    }
}

public class TicketTest5 {
    public static void main(String[] args) {
        Ticket4 r = new Ticket4();

        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  1. Lock锁
    与前两种方法的区别：前两种方法在执行完相应的同步代码以后，自动释放同步监视器；但是Lock锁需要手动启动同步也需要手动结束同步。
import java.util.concurrent.locks.ReentrantLock;

class Ticket5 implements Runnable{

    private int ticket = 100;

    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){

            lock.lock();
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ": " + ticket);
                ticket--;
            }else {
                break;
            }
            lock.unlock();
        }
    }
}

public class TicketTest6 {
    public static void main(String[] args) {
        Ticket5 r = new Ticket5();

        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

优先使用顺序：Lock锁——>同步代码块（已经进入方法体，分配了相应资源）——>同步方法（在方法体之外）

线程的通信

wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。

sleep()和wait()的异同：
相同点：一旦执行都可以使得线程进入阻塞状态。
不同点：方法声明位置不同，Thread类中声明sleep()，Object类中声明wait()；调用要求不同，sleep()可以在任何需要的场景下调用，wait()必须在同步代码块或同步方法中调用；sleep()不会释放同步监视器，wait()会释放同步监视器。

notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll()：唤醒正在排队等待资源的所有线程结束等待.

这三个方法只有在synchronized 方法或者synchronized 代码块中才能使用。
调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException异常。
这三个方法定义在java.lang.Object类中。

生产者—消费者问题

class Clerk{
    private int productCount = 0;
    public synchronized void produceProduct(){
        if(productCount < 5){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void consumeProduct(){
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producer implements Runnable{
    private Clerk clerk;
    public Producer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":开始生产产品");
        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

class Consumer implements Runnable {
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":开始消费产品");
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

public class ProducerAndConsumer {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);

        Thread t1 = new Thread(p1);
        Thread t2 = new Thread(c1);
        Thread t3 = new Thread(c1);

        t1.setName("生产者");
        t2.setName("消费者1");
        t3.setName("消费者2");

        t1.start();
        t2.start();
        t3.start();
    }
}
郁萌萌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程无效_JAVA多线程 问题 转载
weixin_30419031的博客
02-25 893
1.Java 中多线程同步是什么？在多线程程序下，同步能实现控制对共享资源的访问。如果没有同步，当一个 Java 线程在修改一个共享变量时，另外一个线程正在使用或者更新同一个变量，这样容易导致程序出现错误的结果。2.解释实现多线程的几种方法?1> Java 线程可以实现 Runnable 接口:(当你打算多重继承时，优先选择实现 Runnable)[java]classFooimple...
java多线程无效_java多线程
weixin_30368981的博客
02-25 909
第十七天知识点总结一、多线程进程：就是正在运行的程序，分配内存让应用程序能够运行。Windows 号称多任务(可以同时运行多个应用程序)。宏观上看：windows确实是运行了多个程序。微观上看：CPU快速切换执行任务，由于速度特别快，我们人感觉不到这个切换的过程。线程：线程在一个进程中负责代码的执行，就是一个进程中的执行路径。疑问：没有学习线程，为什么代码可以执行。Java程序在运行的时候，jvm...
java多线程无效,关于 Java 多线程的几点疑问，求助大佬
weixin_39620679的博客
03-21 111
Java 多线程的线程安全需要保证原子性和可见性，volatile 关键字可以保证可见性不能保证原子性，synchronized 关键字可以保证可见性和原子性，不过有几点疑问请教一下大佬：(1)volatile 关键字如何保证的可见性，在书上和博客上看到了两种不同的说法，不知道哪种正确：1.赋值操作后会立即写回主内存，一个线程数据回写到主内存会导致其他线程对应数据无效(通过嗅探总线上传输的数据检查...
java 多线程不执行命令_Java多线程疑难点
weixin_30421043的博客
02-16 1411
进程和线程Java的多线模型JMM问题可以总结为 2 个核心，3个要点2个核心：主内存，工作内存缓冲区 重点 主内存和 工作内存缓冲区的数据不一致问题，原因是工作内存缓冲区是线程私有的，数据更新后，同步到主内存有时间差，而另外一个原因重排序，编译器会对指令进行优化重拍。3个要点：原子性，可见性，有序性(happen-before) happen-before原则保证了某些指令必须在前面或者...
java 多线程异常_java多线程执行异常
weixin_39883079的博客
02-15 95
循环次数只有十次，执行的速度太快了，几乎可以忽略不计了，这正好说明了主线程直接先执行，然后Thread启动了run方法其次执行的道理，如果你想看到更真实的效果我建议你在线程中添加延迟，这样可以看的更加清除，代码如下：packagecom.test;/***@作者王建明*@创建日期2013-07-19*@创建时间09:21:26*@版本号V1.0*/publicclassSe...
Java之多线程
qq_45834459的博客
01-01 114
一、程序、进程、线程 1. 程序(program) 概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。 2. 进程(process) 概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 3. 线程(thread) 概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。 内存结构： 进程可以细化为多个线程。
java之多线程
匆匆那些年
07-15 845
什么叫做进程？ 进程是操作系统中的一个任务，他是包含了某些资源的内存区域。一个进程可以包含了一个或多个执行单元称作线程，这些线程可以被看做是同时执行的(实际是轮流占用CPU资源，快速切换，达到看似同时执行)。每个进程还有一个私有虚拟的地址空间，该空间只能被包含的线程所访问。当操作系统创建一个进程之后，该进程会自动申请一个名为主线程的线程。 什么叫做线程？ 一个线程是进程的一个顺序执行流，同类
JAVA之多线程（基础图）
02-20
JAVA之多线程（基础图）
Java之多线程之实现Runnable接口
xlj971021的博客
11-17 1400
Java之多线程之实现Runnable类
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
java向多线程中传递参数的三种方法详细介绍
09-05
以下将详细介绍三种向Java多线程传递参数的方法。 1. **通过构造方法传递数据** 当创建Thread类或其子类的实例时，可以利用构造方法来传递数据。这些数据通常存储为类的成员变量，在`run()`方法中使用。例如： ``...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
【Java】一个经典的多线程错误
weixin_30627341的博客
07-06 75
class Foo { private static initialized = false; private static instance = null; public static void getInstance() { if (!initialized) { synchronize(foo.class) { ...
SpringBoot多线程无法实现原因
wojadhi的博客
03-12 499
解决springboot多线程调用失败问题
Java中schedule调度实现多线程不成功原因
qq_32115101的博客
07-26 427
添加scheduleconfig后： @Configuration @EnableAsync public class ScheduleConfig { @Bean public TaskScheduler taskScheduler() { ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler(); taskScheduler.setPoolSize(50); ...
Java【多线程基础3】导致线程不安全的 4 种原因及解决方式
yzhcjl_的博客
03-20 1852
本篇带你了解Java多线程中线程不安全的原因和解决方案!! 代码示例+解析
java线程不并行_《剖析Java线程到底是并行还是并发》
weixin_42315537的博客
03-02 916
我们都知道线程是最基本的执行单元，包含在进程内部，也就是说，进程是由线程构成。那么当我们编写多线程的时候，大部分教科书上都是称其为并发，而非是并行，这2种截然不同的概念，完全误导了一些同学。并发：多线程运行在同一个CPU内，CPU不停做上下文切换执行任务，单位时间内只有一个线程在运行；并行：多线程运行在多核心CPU内，同时执行任务；在笔者面试过的部分开发人员中，有些人会觉得Java线程被包裹在1个...
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 3229
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
Java实现多线程下载工具
"疯狂java实例-第11章_多线程下载工具" 在Java编程领域，多线程下载工具的实现是一项重要的技能，它能够帮助用户高效地管理和下载网络资源。本章节主要聚焦于如何使用Java来开发一个支持HTTP协议的多线程下载工具，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值