Java多线程

最新推荐文章于 2024-11-11 00:03:55 发布
最新推荐文章于 2024-11-11 00:03:55 发布
阅读量92 收藏
点赞数
分类专栏： Java SE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48642210/article/details/123388739
版权

一、线程

1.1 并发与并行的概念(重点)

  1. 程序: 一个固定逻辑与数据的集合就是程序 例如 俄罗斯方块 贪吃蛇
  2. cpu: 中央处理器 主要用于协调程序与硬件的工作
  3. 并发与并行
    • 并发(高并发): 在同一一个时间段 执行两个 或者多个程序的 单核cpu 交互的执行 由于cpu切换的速度比较块
      可能产生的误区 是同时执行 是交替执行
    • 并行:在同一个时刻 执行两个或者是多个程序的时候 多核cpu 同时执行 目前电脑都是多核的cpu
      例子:看小电影 听音乐 例子:玩游戏 键盘侠

1.2 进程与线程(了解)

1. 进程:运行在内存中的程序就是进程 例子:idea   百度网盘   画图的工具
2. 线程:通向cpu的执行的路径就是线程
3. 线程分类:单线程与多线程
   		单线程: 只有一条通向cpu的执行的路径 就是单线程
   		多线程: 多条通向cpu的执行的路径 就是多线程

1.4 线程的五种状态

  1. 新建状态
  2. 就绪状态
  3. 阻塞状态/等待/睡眠
  4. 运行状态
  5. 死亡状态

1.3 创建线程的方式

1.3.1 继承Thread类

步骤：

  1. 定义一个类继承Thread
  2. 重写run()方法 执行线程的操作
  3. 实例化这个线程类的对象
  4. 调用start() 方法 开启线程
1.3.2 实现Runnable接口（重点）

步骤：

1. 定义一个类 实现 Runnable
2. 重写run()方法
3. 实例化线程对象 Thread    传递一个参数 Runnable 的实现类
4. 通过Thread对象调用方法开启线程  start()
1.3.3 使用匿名内部类创建多线程（重点）
package com.ahao;
public class Test01 {
    public static void main(String[] args) {
        //第一种方式
         new Thread(new Runnable() {
             @Override
             public void run() {
                 System.out.println(Thread.currentThread().getName());
             }
         }).start();
         //第二种方式
        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }.start();
    }
}
1.3.4 实现Callable接口(重点)
1. 定义一个类实现接口 Callable
2. 重写call()方法
3. 实例化 任务对象 FutureTask  构建一个Callable的实现类
4. 实例化线程对象 Thread  构建一个任务对象
5. 开启线程
6. 调用任务对象的get() 获取其返回值

线程类代码：

import java.util.concurrent.Callable;

public class MyCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
            sum+= i;
        }
        return sum;
    }
}

测试类代码：

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable callable = new MyCallable();
        //实例化任务对象
        FutureTask<Integer> task = new FutureTask<>(callable);
        //构建任务对象
        new Thread(task).start();
        Integer sum = task.get();
        System.out.println("1+2+......+99+100="+sum);
    }
}
1.3.5 线程池

简介：用于来管理与维护线程

步骤：

1. 通过线程池的工具类来创建线程对象
2. 创建一个线程任务对象
3. 将任务对象提交线程池中
4. 通过get() 获取到线程执行完的结果

线程类代码1：

import java.util.concurrent.Callable;

public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        return Thread.currentThread().getName()+"\t"+"666";
    }
}

线程类代码2：

public class MyRunnable implements Runnable{
  @Override
  public void run() {
      System.out.println(Thread.currentThread().getName()+"\t"+"Runnable");
  }
}

测试类：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);//设置线程数量
        MyRunnable r1 = new MyRunnable();
        MyRunnable r2 = new MyRunnable();
        MyCallable callable = new MyCallable();
        Future future = pool.submit(callable);
        System.out.println(future.get());

        pool.submit(r1);
        pool.submit(r2);
        pool.submit(r1);
        pool.submit(r2);
        pool.submit(r1);
    }
}

二、线程中的方法（重要）

2.1 线程休眠

方法的名称方法 的描述
public static void sleep(long millis)public static void sleep(long millis)

2.2 守护线程

1. 守护线程:守护其它的线程  守护其它线程执行完操作  java中gc垃圾回收器 jav程序在运行期间 都会出现垃圾，这个九垃圾就是由gc来默默进行回收 gc就是一个守护的线程
2. 守护线程的死亡: 被守护的线程执行完操作 或者是死亡 那么守护线程也就是死亡
3. 一般守护线程都是守护主线程
方法的名称方法的描述
public final void setDaemon(boolean on)设置为守护线程
public final boolean isDaemon()测试该线程是否为守护线程

2.3 线程的优先级

2.3.1 优先级常量
常量的名称常量的描述
public static final int MAX_PRIORITY线程可以具有的最高优先级
public static final int MIN_PRIORITY线程可以具有的最低优先级
public static final int NORM_PRIORITY分配给线程的默认优先级
    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

注意点:

A.线程的最高优先级是10 线程的最低优先级是1 范围 1-10

B.线程优先级越高 表示获取cpu执行权越大 并不一定会执行 java 抢占式调度

2.3.2 方法
方法的名称方法的描述
public final int getPriority()返回的是线程的优先级
public final void setPriority(int newPriority)更改线程的优先级

2.4线程常用的方法(重点)

方法的名称方法的说明
public final void stop()强迫线程停止执行
public static void yield()暂停当前正在执行的线程对象，并执行其他线程(礼让)
public final void join()等待该线程终止(方法必须在线程开启之后进行调用)
2.4.1 stop的代码演示
package com.qf.demo03;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            if (i==5){
                //终止线程
                stop();
            }
            System.out.println(i);
        }
    }
}


package com.qf.demo03;

public class Test01 {
    public static void main(String[] args) {
     //实例化线程对象
        MyThread t  = new MyThread();
        t.start();
    }
}
2.4.2 yield的代码演示
package com.qf.demo04;

public class MyThread extends  Thread {

    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println(getName()+"\t"+i);

        }
    }
}


package com.qf.demo04;

public class Test01 {
    public static void main(String[] args) {
        MyThread t1= new MyThread();
        t1.yield();
        t1.start();
        MyThread t2 = new MyThread();
        t2.start();
    }
}
2.4.3 join 方法代码演示
package com.qf.demo05;

public class MyThread extends  Thread {

    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println(getName()+"\t"+i);

        }
    }
}


package com.qf.demo05;

public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1= new MyThread();
        t1.start();
        t1.join();
        MyThread t2 = new MyThread();
        t2.start();
    }
}

三、Object 提供操作线程的方法(重点)

3.1 方法的介绍

方法的名称方法的描述
public final void wait()无限等待(需要被唤醒)
public final void wait(long timeout)计时等待
public final void notify()唤醒在此对象监视器上等待的单个线程(一个)
public final void notifyAll()唤醒在此对象监视器上等待的所有线程(多个)

四、线程通信

4.1案例：

A.每一个窗口就是一个线程 使用线程来表示多窗口售票
B.数据共享 使用第二种方式来创建线程
C.定义一个变量来表示票数
D.循环售票

线程不安全案例代码：

public class MyRunnable implements Runnable{
    //定义一个变量来记录票数
    private  int  count=100;
    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //使用循环一直买票
        while (true){
            if (count > 0) {
                System.out.println(Thread.currentThread().getName()+"\t"+"您购买是第"+count+"张票");
                count--;
            }
        }

    }
}


public class Test01 {
    public static void main(String[] args) {
        //实例化MyRunnable对象
        MyRunnable runnable = new MyRunnable();
        //实例化线程
        Thread t1 = new Thread(runnable);
        t1.start();
        //实例化线程
        Thread t2 = new Thread(runnable);
        t2.start();
        //实例化线程
        Thread t3 = new Thread(runnable);
        t3.start();

    }
}

4.2 第一种解决方案-同步代码块

1.语法:
    synchronized(锁对象) {
          可能产生问题的代码
    }
2.注意点
   A.锁的对象可以是任意的对象 
   B.所有线程锁的对象必须是同一个对象
3.作用:
    解决数据共享安全的问题

解决代码：

public class MyRunnable implements Runnable{
    //定义一个变量来记录票数
    private  int  count=100;
    //定义一个锁的对象
    private  Object obj  = new Object();
    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //使用循环一直买票
        while (true){
            synchronized (obj) {
                if (count > 0) {
                    System.out.println(Thread.currentThread().getName()+"\t"+"您购买是第"+count+"张票");
                    count--;
                }
            }
        }

    }
}

4.3 第二种解决方案 -同步方法

1.语法:
  访问修饰符 synchronized  返回值类型  方法的名称(参数列表) {
        方法体
      retrun  返回值
  }
2.说明:同步方法可以是普通的成员方法   也可以是静态的方法
3.说明:
   A.成员方法的锁的对象就是this
   B.静态方法锁的对象是当前类的class对象

解决代码：

public class MyRunnable implements Runnable{
    //定义一个变量来记录票数
    private static int  count=100;
    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //使用循环一直买票
        while (true){
            showInfo();         
        }
    }
   //同步方法
    public   static synchronized  void   showInfo() {
        if (count > 0) {
            System.out.println(Thread.currentThread().getName()+"\t"+"您购买是第"+count+"张票");
            count--;
        }
    }
}

4.4 第三种解决方案-锁

1.Lock 简介
 A.Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
 B.此实现允许更灵活的结构
2. 实现类ReentrantLock
3.方法
方法的名称方法的描述
void lock()获取锁
void unlock()释放锁

解决代码：

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

public class MyRunnable implements Runnable{
    //定义一个变量来记录票数
    private  int  count=1000;
    //实例化Lock锁对象
    private Lock   l = new ReentrantLock();
    @Override
    public void run() {
        //获取锁对象
        l.lock();
        try {
            Thread.sleep(500);
            //使用循环一直买票
            while (true){

                    if (count > 0) {
                        System.out.println(Thread.currentThread().getName()+"\t"+"您购买是第"+count+"张票");
                       count--;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //释放锁对象
            l.unlock();
        }
    }
}

五、死锁

  1. 死锁: A占用B的锁对象 B占用的A的锁对象 互补谦让 两个线程都处于等待状态 出现了死锁

六、生产者与消费者模式(重点)

6.1简介：

生产者不能一直生产,消费者不能一直消费

​ 生产者生产产品 —> 等待消费者消费

​ 消费者购买完产品—>等待生产者生产

6.2 案例代码：

产品类：

public class BaoZi {
    public  String pi;
    public  String xian;
    //如果false 表示没有包子  为true表示有包子
    public  boolean  flag = false;
}

线程类-01：

public class MyThread01 extends Thread {
    private BaoZi baoZi;
    public MyThread01(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baoZi){
                try {
                    if (baoZi.flag) {
                        baoZi.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                baoZi.pi = "薄皮";
                baoZi.xian = "肉馅";
                System.out.println("生产了一个" + baoZi.pi + baoZi.xian + "的包子");
                baoZi.flag = true;
                baoZi.notify();
            }
        }

    }
}

线程类-02：

public class MyThread02 extends Thread {
    private BaoZi baoZi;
    public MyThread02(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baoZi){
                try {
                    if (!baoZi.flag) {
                        baoZi.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我吃了一个" + baoZi.pi + baoZi.xian + "的包子");
                baoZi.pi = null;
                baoZi.xian = null;
                baoZi.flag = false;
                baoZi.notify();
            }
        }

    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        BaoZi baoZi = new BaoZi();
        new MyThread01(baoZi).start();
        new MyThread02(baoZi).start();
    }
}
JavaAhao
关注
专栏目录
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
java.util.concurrent.RejectedExecutionException
松门一枝花
05-28 4826
报错日志 java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@12e2cb93 rejected from java.util.concurrent.ThreadPoolExecutor@6ecd396b[Running, pool size = 10, active threads = 10, queued tasks = 200, completed tasks = 0] 原.
java多线程
m0_46702681的博客
06-19 2238
javajava。
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
热门推荐
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
Java多线程详解
坏蛋阿土的博客
11-06 6625
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
Java多线程读取文件
Mr-Bean的博客
08-16 2472
package com.qwx.test; import java.io.*; /** * @ClassName: ReadFile * @Description: java类作用描述 * @Author: qiaowenxuan * @CreateDate: 2021/8/16$ 18:36$ * @Version: 1.0 */ public class ReadFile { public static void main(String[] args) { Fil
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
Java 多线程 测试
风信子
04-14 1964
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
JAVA多线程实战
超级氯化钾的博客
07-21 2811
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4880
Java多线程(四)线程锁
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
Java基础07
最新发布
m0_74977981的博客
11-11 478
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
JAVA-01-变量
LJH_laura_li的博客
11-08 335
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 835
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 638
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值