javaSE-多线程

最新推荐文章于 2024-04-19 19:47:10 发布
最新推荐文章于 2024-04-19 19:47:10 发布
阅读量126 收藏
点赞数
分类专栏： javaSE笔记 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40668912/article/details/109941350
版权

概述

java也是支持多线程的，因为java是oop语言，所以java中的多线程就是操作java库中的Thread类以及它的API。

创建方式

  1. 新建继承自定义类然后继承Thread类，重写里面的run()方法，最后调用start()方法。
  2. 新建一个类去实现Runnable接口，实现run()方法，然后new Thread(Runnable r)创建一个Thread对象，调用start()方法。
  3. 新建一个类去实现Callable接口，实现run()方法，然后new FutureTask<>(Callable c)创建一个FutureTask对象，再然后new Thread(FutureTask f)创建一个Thread对象，调用start()方法。
    demo示例如下：
/**
 * @Classname CreateThread
 * @Date 2020/11/22 13:00
 * @author hzq
 */
package com.hzq.create;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CreateThread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //方式一
        MyThread1 thread1 = new MyThread1();
        thread1.start();
        //方式二
        Thread thread2 = new Thread(new MyThread2());
        thread2.start();
        //方式三
        FutureTask<Boolean> task = new FutureTask<>(new MyThread3());
        Thread thread3 = new Thread(task);
        thread3.start();
        Boolean b = task.get();
        System.out.println(b);
    }
}

//方式1
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("使用继承Thread的方式创建线程");
    }
}
//方式2
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable的方式创建线程");
    }
}
//方式3
class MyThread3 implements Callable<Boolean>{
    @Override
    public Boolean call() throws Exception {
        System.out.println("实现Callable的方式创建线程");
        return true;
    }
}

ps：开发时不要使用第一种。不要调用run()方法，当我们new 一个Thread对象时，其实就是创建了一个线程，只有当调用了start()方法时，这个线程才会进入就绪状态，然后等待cpu调度获取执行权，调用run()方法相当于调用一个普通类的一个普通方法。方式三可以有返回值。

API

在前面的3种创建方式中可以看出，java对多线程的操作，其实就是学会使用Thread类的各种API接口。下面会简单介绍几个常用的方法，有兴趣的可以去查一下jdk文档。

  1. sleep方法，使线程阻塞一定的时间
    demo示例：
/**
 * @Classname TestSleep
 * @Date 2020/11/22 13:24
 * @author hzq
 */
package com.hzq.api;

public class TestSleep {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0;i<10000;i++){
            System.out.println(i);
        }
        //当程序运行到这里,会阻塞5秒,然后继续执行.
        Thread.sleep(5000);
        System.out.println("线程结束");
    }
}
  1. yield方法，使线程让出cpu，然后与其他线程重新竞争cpu的执行权。（有可能没有效果）
    demo示例：
/**
 * @Classname TestYield
 * @Date 2020/11/22 13:35
 * @author hzq
 */
package com.hzq.api;

public class TestYield {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Yield1(),"线程一").start();
        Thread.sleep(10);
        new Thread(new Yield2(),"线程二").start();
    }
}

class Yield1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i < 1000; i++){
            System.out.println(Thread.currentThread().getName()+"------->开始执行");
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"------->结束执行");
        }
    }
}

class Yield2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i < 1000; i++){
            System.out.println(Thread.currentThread().getName()+"------->开始执行");
            System.out.println(Thread.currentThread().getName()+"------->结束执行");
        }
    }
}

ps:可以把Thread.yield()注释掉看看输出效果，对比一下就可以看出来yield方法的效果了

  1. join方法，强制获取cpu权限，阻塞其他的线程，直到自身结束。
    demo示例：
/**
 * @Classname TestJoin
 * @Date 2020/11/22 13:51
 * @author hzq
 */
package com.hzq.api;

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Join1(), "线程一");
        thread.start();
        for (int i = 0; i < 500; i++) {
            if (i == 200){
                thread.join();
            }
            System.out.println("main线程---->"+i);
        }
    }
}

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

ps:可以将thread.join()方法注释掉看看输出效果。
4. setPriority方法，设置线程的优先级，从一到十，线程开启之后设置无效，必须在线程开启之前设置，默认是5，线程的优先级只是权重的大小，并不代表优先级高的一定比优先级低的先执行，更像是两个人买彩票，甲买了100张彩票，已买了1张，那么甲中奖的概率一定大于已。
demo示例：

/**
 * @Classname TestPriority
 * @Date 2020/11/22 14:11
 * @author hzq
 */
package com.hzq.api;
//测试线程优先级
public class TestPriority {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Priority(),"优先级1");
        thread1.setPriority(1);
        Thread thread2 = new Thread(new Priority(),"优先级4");
        thread2.setPriority(2);
        Thread thread3 = new Thread(new Priority(),"优先级6");
        thread3.setPriority(6);
        Thread thread4 = new Thread(new Priority(),"优先级10");
        thread4.setPriority(10);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

    }
}

class Priority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---->执行");
    }
}
  1. setDaemon()方法，设置该线程为守护线程。jvm只会关心用户线程是否执行结束，不会操心守护线程，一旦用户线程全部执行完毕后，jvm就会自动退出，不会管守护线程是否执行结束。
    demo示例：
/**
 * @Classname TestDaemon
 * @Date 2020/11/22 14:22
 * @author hzq
 */
package com.hzq.api;
//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        Thread daemon = new Thread(new Daemon(), "守护线程");
        Thread user = new Thread(new UserThread(), "用户线程");
        //设置该线程为守护线程
        daemon.setDaemon(true);
        daemon.start();
        user.start();
    }
}

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

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

ps:可以试着将true改成false。

线程同步

概述

多线程中最大的问题就是线程的同步问题，比如两个线程同时调用一台打印机打印东西，就有可能会出现问题。同样的，当多个线程同时操作一个共享变量时，也会有概率发生错误。线程同步的基本原理其实就是让临界资源同时只能被一个线程所操作。java中的线程同步大部分是使用synchronized关键字来进行，在java5中引进了Lock类，现在Lock类的使用优先级要比synchronized关键字更高，也就是说推荐使用Lock类。

1. synchronized关键字

  1. 用法
    synchronized关键字可以用在方法上以及代码块上
  2. 原理
    当synchronized关键字用在代码块上时，需要传入一个任意对象来当锁，当多个线程同时调用该代码块时，需要先去获取锁对象，只有持有锁对象的线程，才能去调用该代码块，否则只能阻塞等待持有锁对象的线程执行完这个代码块后释放锁对象，然后再进行竞争成为锁对象的持有者。
    当synchronized关键字用在普通方法上时，锁对象是this，即当前对象，如果该方法是静态方法时，锁对象是当前对象的Class对象。
    demo示例：
/**
 * @Classname TestSynchronized
 * @Date 2020/11/22 14:47
 * @author hzq
 */
package com.hzq.synchronous.synchronizedfont;
//测试synchronized关键字
public class TestSynchronized {
    public static void main(String[] args) {
        TicketOffice ticketOffice = new TicketOffice();
        Thread thread1 = new Thread(ticketOffice, "售票厅一");
        Thread thread2 = new Thread(ticketOffice, "售票厅二");
        Thread thread3 = new Thread(ticketOffice, "售票厅三");
        Thread thread4 = new Thread(ticketOffice, "售票厅四");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

    }
}

class TicketOffice implements Runnable{
    private static int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket <= 0){
                break;
            }
            sellTicket();
        }

    }
    public synchronized void sellTicket(){
        if (ticket > 0){
            System.out.println(Thread.currentThread().getName()+"售出第"+ticket+"张票");
            ticket--;
        }
    }
}

ps: 将synchronized关键字去掉再运行看看结果有什么区别。

2. Lock类

  1. 简介
    Lock锁是java5出现的一种同步机制，它拥有比synchronized关键字更加优秀的性能，以及更加清晰的结构，使用方法也很简单，只需要在需要同步的代码块之前调用lock()方法，离开代码块要调用unlock()方法即可。
    demo示例：
/**
 * @Classname TestSynchronized
 * @Date 2020/11/22 14:47
 * @author hzq
 */
package com.hzq.synchronous.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//测试synchronized关键字
public class TestLock {
    public static void main(String[] args) {
        TicketOffice ticketOffice = new TicketOffice();
        Thread thread1 = new Thread(ticketOffice, "售票厅一");
        Thread thread2 = new Thread(ticketOffice, "售票厅二");
        Thread thread3 = new Thread(ticketOffice, "售票厅三");
        Thread thread4 = new Thread(ticketOffice, "售票厅四");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

class TicketOffice implements Runnable{
    private static int ticket = 100;
    private static Lock lock =new ReentrantLock();
    @Override
    public void run() {
        while (true){
            if (ticket <= 0){
                break;
            }
            sellTicket();
        }

    }
    public  void sellTicket(){
        lock.lock();
        try {
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName()+"售出第"+ticket+"张票");
                ticket--;
            }
        }finally {
            lock.unlock();
        }
    }
}

线程池

  1. 概述
    频繁的创建线程，线程执行结束后销毁线程都是十分耗费资源的，所以出现了线程池技术，它类似于数据库的数据库连接池。当需要使用多线程去执行程序的时候从线程池中拿出已经创建好的线程，等用完以后再将线程放回去。
  2. 使用方法
    通过Executors类的静态方法newFixedThreadPool()方法创建一个线程池，然后使用execute()方法去执行Runnable类，使用submit()方法去执行Callable类。
    demo示例：
/**
 * @Classname TestThreadPool
 * @Date 2020/11/22 15:18
 * @author hzq
 */
package com.hzq.ThreadPool;

import java.util.concurrent.*;

public class TestThreadPool {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
        //2.执行Runnable
        pool.execute(new MyThread2());
        //3.执行Callable
        Future<Boolean> future = pool.submit(new MyThread3());
        System.out.println(future.get());
        pool.shutdownNow();
    }
}
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable的方式创建线程");
    }
}
//方式3
class MyThread3 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        System.out.println("实现Callable的方式创建线程");
        return true;
    }
}
潇湘夜雨灬奇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CompletableFuture异步编程
m0_61364397的博客
11-06 153
默认情况下CompletableFuture会使用公共的ForkJoinPool线程池，这个线程池默认创建的线程数是CPU的 核数（也可以通过JVM option:-Djava.util.concurrent.ForkJoinPool.common.parallelism来设置ForkJoinPool 线程池的线程数）。如果所有CompletableFuture共享一个线程池，那么一旦有任务执行一些很慢的I/O操 作，就会导致线程池中所有线程都阻塞在I/O操作上，从而造成线程饥饿，进而影响整个系统的性能..
JavaSE-多线程-使用多线程轮流打印1-100
ZeroBUG666的博客
03-29 2105
线程通信。
谷粒商城异步编排(三十一)
qq_29860591的博客
07-07 501
CompletableFuture异步编排(193-202) /** * @author WGR * @create 2020/7/7 -- 19:34 */ public class ThreadTest { public static ExecutorService executor = Executors.newFixedThreadPool(10); p...
【异步操作工具 CompletableFuture 详解】
最新发布
Java之行
04-19 2864
CompletableFuture方法详解
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
JavaSE-多线程(实现线程安全的三种方式)
weixin_43958460的博客
09-09 739
多线程的线程安全问题 案例：如何使用多线程实现卖票问题？ 给出100张票，让3个线程一起买票，且保证票的唯一性和合法性 实现方式一：使用同步代码块 public class RunnableImpl implements Runnable{ //定义一个多个线程共享的票源 private int ticket = 100; //创建一个锁对象 Object ob...
JavaSE --- 多线程
MemoryTa的博客
08-06 257
多线程。。概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法。............
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
Java8新的异步编程方式CompletableFuture实现
08-26
主要介绍了Java8新的异步编程方式CompletableFuture实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
CompletableFuture异步线程
weixin_45205175的博客
07-28 292
CompletableFuture异步线程
CompletableFuture 异步处理
沉淀、分享、成长，让自己和他人都能有所收获！
07-16 5353
我们传统的程序都是单线程的，程序的运行是同步的。（一个执行完一个执行）比如查询A表要20秒,查询B表也要20秒那么在同步执行的情况下总共需要40秒的时间。而异步处理是将这2个查询异步的去进行，总共只需要20秒，极大的提高了系统的吞吐量。异步就是从主线程发射一个子线程来完成任务.大家对异步有一个简单认识之后；......
CompletableFuture 异步编排
老男孩的架构路
08-16 531
在 Java8 中，新增了 CompletableFuture 异步编程工具类。它与我们之前使用的 Future 接口有何区别呢？本文将对这个重要的 CompletableFuture 类进行分析学习。1、runXxx 都是没有返回结果的，supplyXxx 都是可以获取返回值的；2、可以传入自定义的线程池，否则就用默认的线程池：ForkJoinPool.commonPool()；3、Async 代表异步的意思。2.1 获得结果和触发计算获得结果get() :不见不散。...
CompletableFuture使用详解（全网看这一篇就行）
热门推荐
搬砖老农工的博客
04-02 8万+
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 1. supplyAsync supplyAsync是带有返回值的异步任务。它有如下两个方法，有一个是带有线程池的重载方法 // 带返回值异步请求，默认线程池 public static <U> Completa
异步编程 CompletableFuture详解
TheLudlows的博客
11-29 1403
文章目录1. CompletableFuture概述2. How to use2.1 创建CompletableFuture2.2 获取结果2.3 转换操作2.4 组合操作2.5 完成时处理2.6 异常处理 1. CompletableFuture概述 在异步编程中，Future/Promise模式是一种广泛使用的异步开发模式，其中 Future 对象代表一个尚未完成异步操作的结果。从JDK 1....
CompletableFuture（异步编程）
qq_40357769的博客
08-15 117
CompletableFuture的由来 CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 代码示例（一） thenCombine（合并） public class Futrue { public static void main(String[] args) { System.out.println("
CompletableFuture 异步编程
小强快跑~~
06-09 450
本文从实例出发，介绍CompletableFuture基本用法。不过讲的再多，不如亲自上手练习一下。所以建议各位小伙伴看完，上机练习一把，快速掌握CompletableFuture。 全文摘要： FutureVSCompletableFuture CompletableFuture基本用法 0x00. 前言 一些业务场景我们需要使用多线程异步执行任务，加快任务执行速度。Java 提供RunnableFuture<V>两个接口用来实现异步任务逻辑。 虽然...
【异步 CompletableFuture】
hupengfei_shenyang的博客
05-03 337
线程池 初始化线程的四种方法 1.继承Thread Thread01 thread = new Thread01(); thread.start(); 2.实现runnable接口 Runable01 runable = new Runable01(); Thread thread = new Thread(runable); thread.start(); 3.实现Callable接口+FutureTask Callable01 callable = new Callable01(); Futur
JavaSE多线程编程详解：创建与管理
"JavaSE多线程编程专题.pptx" 在JavaSE中，多线程编程是一项核心技能，它允许程序并发执行多个任务，提高系统资源利用率和响应速度。多线程涉及到进程和线程两个概念。进程是操作系统分配资源的基本单位，每个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值