Java 简单笔记——多线程

最新推荐文章于 2023-09-17 19:20:06 发布
最新推荐文章于 2023-09-17 19:20:06 发布
阅读量214 收藏 1
点赞数
分类专栏： Java 笔记 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjs1453100406/article/details/109246060
版权
Java 同时被 2 个专栏收录
45 篇文章 1 订阅
订阅专栏
笔记
33 篇文章 0 订阅
订阅专栏

多线程

一、实现多线程

1.1.前导

  • 实现继承有两种方法：
    1.使实例化对象的类继承与Thread类；
    2.使实例化对象的类实现Runnable接口；
  • 其实Thread类也是实现与Runnable接口的，在加上Java有着单继承多实现的特性，所以第二种方法要优于第一种；在这里插入图片描述
  • 无论那种方法都必须重写run()方法，并且完成工作的代码段需要放到里面；在这里插入图片描述
  • 多线程的启动方式为对象.start(),而不能使用对象.run(),否则将失去多线程的效果在这里插入图片描述
  • Thread.currentThread()方法：返回当前线程执行的引用；
  • Thread.sleep（）方法：使得该线程睡眠一段时间后执行，并不会释放锁；

1.2.继承Thread类

public class Testclass {
    public static void main(String[] args){
        FileTran ft1=new FileTran("文件1");
        ft1.start();//start();启动多线程
        FileTran ft2=new FileTran("文件2");
        ft2.start();
        FileTran ft3=new FileTran("文件3");
        ft3.start();
    }
}
class FileTran extends Thread{
    private String name;
    public FileTran(String name){
        this.name=name;
    }
    public void run(){
        System.out.println("传送"+name);
        try{
            Thread.sleep(1000);//sleep让程序睡眠1秒（1000毫秒）
        }catch (Exception e){}

        System.out.println(name+"传送完毕");
    }
}

运行结果：
在这里插入图片描述
也可以使用匿名对象来实现：

public class Testclass {
    public static void main(String[] args){
        new Thread(){
            public void run(){
                System.out.println("文件传输1");
            }
        }.start();
    }
}

在这里插入图片描述

1.3.实现Runnable接口

由于接口Runnable中没有start方法，而启动多线程又必须需要start方法,所以在对象外面包装一个Thread的实例化的对象；将原有对象作为形参传递进去便可包装出一个线程

public class Testclass {
    public static void main(String[] args){
      FileTran ft1=new FileTran("文件");
      //由于接口Runnable中没有start方法，而启动多线程又必须需要start方法；
      //所以在对象外面包装一个Thread的实例化的对象;
      Thread t1=new Thread(ft1);
      t1.start();

      Thread t2=new Thread(ft1);//实现多线程
      t2.start();
    }
}
class FileTran implements Runnable{//这些为线程要执行的代码，并非多线程；
    private String name;
    public FileTran(String name){
        this.name=name;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread()+"传送"+name);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread()+name+"传送完毕");
    }

}

在这里插入图片描述
也可以使用匿名对象来实现：

public class Testclass {
    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread()+"传送文件");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread()+"文件传送完毕");
            }
        }).start();
        //创建第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread()+"传送文件");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread()+"文件传送完毕");
            }
        }).start();
    }
}

在这里插入图片描述

1.4.两种方法的区别

继承Thread有以下几个特点：

  • 每一个对象都是一个线程，其对象有自己的成员变量；
  • 继承了Thread类就不能再继承其它的类；

所以，“继承Thread”的使用常常用于实现多个完全不同的线程的对象处理和声明，同时也用于创建一个专用的线程类；


实现Runnable接口有以下几个特点：

  • 当前类实现接口后仍然可以实现别的接口或继承其它类；
  • 实现的方法更适合用来处理共享数据的问题，所直接创建的对象并不是一个线程，必须将其传入到Thread中对象才能运行，各个对象是否使用一个Runnable成员对象视情况而定；在这里插入图片描述

1.5.练习

模拟火车票售票窗口，总票为100张

1.继承的方式实现：

//模拟火车票售票窗口，总票为100张（继承方式实现）
public class Testclass {
    public static void main(String[] args){
        Windows w1=new Windows();
        Windows w2=new Windows();
        Windows w3=new Windows();

        w1.setName("窗口1");//setName为Thread中的;
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();

    }
}
class Windows extends Thread{
    static int ticket=100;//添加static声明为共用变量
    public void run(){
        while(true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+
                        "售出票号为"+ticket--);
            }else break;
        }
    }
}

2.实现的方式实现

//模拟火车票售票窗口，总票为100张（实现的方式实现）
public class Testclass {
    public static void main(String[] args){
        Windows w=new Windows();

        Thread w1=new Thread(w);
        Thread w2=new Thread(w);
        Thread w3=new Thread(w);

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();

    }
}
class Windows implements Runnable{
    int ticket=100;//添加static声明为共用变量
    public void run(){
        while(true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+
                        "售出票号为"+ticket--);
            }else break;
        }
    }
}

二、生命周期

在这里插入图片描述

三、线程同步安全

3.1.线程协作安全

上面所练习的两种方法均存在错误——当线程抢到CPU资源后如果没有来得及执行当前代码程序便被挂起，当下一个线程进入后仍然可以操作执行当前代码程序
在这里插入图片描述
使用Thread.currentThread().sleep(100)使得线程的存在的隐患放大；

class Windows implements Runnable{
    int ticket=100;//添加static声明为共用变量
    public void run(){
        while(true){
            if (ticket>0){
                try {
                    Thread.currentThread().sleep(100);//睡眠0.1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+
                        "售出票号为"+ticket--);
            }else break;
        }
    }
}

运行结果：
在这里插入图片描述


解决方法：使用join()方法；
在这里插入图片描述

public class Testclass {
    public static void main(String[] args) throws Exception {//join需要异常处理
        Windows w=new Windows();
        Thread w1=new Thread(w);
        Thread w2=new Thread(w);
        Thread w3=new Thread(w);
        
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w1.join();//等待这个线程死亡。 
        w2.start();
        w3.start();
    }
}

运行结果：
在这里插入图片描述
可以明显看到，虽然解决了极端状态的隐患，但是这样一来所有的操作都是由线程w1来完成，其它的线程根本不参与，这违背了多线程的意义；

结论：join()方法多适用于完成不同工作的多线程操作，当下一线程的操作需要当前线程操作的最终结果才能完成时，应使用此方法；

3.2.线程同步安全

确保Java程序的线程安全：线程的同步机制

3.2.1方法一：同步代码块

格式：

synchronized (同步锁对象/同步监视器) {
	//需要被同步的代码
}

同步监视器也称之为 “锁”， 哪个线程获得此监视器便可以执行代码块里面的代码；该监视器可以被任意一个对象充当,但是必须要确保锁的唯一性

模拟火车票售票窗口，总票为100张（实现的方式实现）

//模拟火车票售票窗口，总票为100张（实现的方式实现）
public class Testclass {
    public static void main(String[] args) {//join需要异常处理
        Windows w=new Windows();

        Thread w1=new Thread(w);
        Thread w2=new Thread(w);
        Thread w3=new Thread(w);

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}
class Windows implements Runnable{
    int ticket=100;//共用变量
    Object obj=new Object();//任意对象
    public void run(){

        while(true){

            synchronized (this) {//这里也可以写obj
                if (ticket>0){
                    try {
                        Thread.currentThread().sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+
                            "售出票号为"+ticket--);
                }else break;
            }

        }
    }
}

3.2.2方法二：同步方法

同步方法的核心：

public synchronized void f1(){
       //f1代码段
}

等价于

public void f1(){
    synchronized (this){
      //f1代码段
    }
}

同步方法：将操作共享数据的方法声明为synchronized， 即此方法为同步方法。

class Windows implements Runnable{
    int ticket=100;//共用变量
    Object obj=new Object();//任意对象

    public void run(){
        while(true){
            show();
        }
 }
public synchronized void show(){
        if (ticket>0){
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+
                    "售出票号为"+ticket--);
        }
    }
}

同步方法也有锁，锁为当前对象，继而在使用 继承Thread类 的时候不能用同步方法

3.3互斥锁

单例模式懒汉式使用同步机制优化；

//单例模式懒汉式
//优化线程安全，使用同步机制
class Singlen {
    private Singlen() {
    }

    private static Singlen instance = null;

    public static Singlen getInstance() {
        if (instance == null) {
            synchronized (Singlen.class) {//由于在static修饰的方法中，所以不能使用this
                //Singlen.class返回时是Class类的对象
                if (instance == null) {//
                    instance = new Singlen();
                }
            }
        }

        return instance;
    }
}

3.4练习

在这里插入图片描述

public class Testclass {
    public static void main(String[] args) {//join需要异常处理
        bank k=new bank();
        Thread k1=new Thread(k,"操作人1");
        Thread k2=new Thread(k,"操作人2");
        k1.start();
        k2.start();
    }
}
class bank implements Runnable{
    private int account;
    public void run(){
        synchronized (this){
        for (int i = 0; i <3 ; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account+=1000;
            System.out.println(Thread.currentThread().getName()+"存入1000元后账户余额为"+account);
        }}
    }
}

运行结果：
在这里插入图片描述

四、线程通信

4.1线程通信用到的方法

在这里插入图片描述

4.2练习

在这里插入图片描述

public class Testclass {
    public static void main(String[] args) {
        Number n=new Number();
        Thread n1=new Thread(n,"线程1");
        Thread n2=new Thread(n,"线程2");
        n1.start();
        n2.start();
    }
}
class Number implements Runnable {
    private int i=1;

    @Override
    public void run() {
        while(true){
            synchronized (this){
                notify();//唤醒wait()的进程
            if (i<=100){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"打印"+i++);
                }else break;
                try {
                    wait();//进入休眠并释放当前的锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

五、最终练习：生产者消费者问题

题目：
在这里插入图片描述

class Clerk{
    int Product;

    public synchronized void addProduct() throws Exception {
       if (Product>=20){
           this.wait();
       }else {
           Product++;
           System.out.println(Thread.currentThread().getName()+"生产了第"+Product+"个产品");
           notifyAll();
       }
    }

    public synchronized void consumeProduct()throws Exception{
        if (Product<=0){
            this.wait();
        }else {
            System.out.println(Thread.currentThread().getName()+"消耗了第"+Product+"个产品");
            Product--;
            notifyAll();

        }
    }
}


class Productor implements Runnable{

    Clerk clerk;//创建一个店员的变量;

    public Productor(Clerk clerk){
        this.clerk=clerk;
    }


    public void run() {
        System.out.println("生产者开始生产产品");
        while (true){
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                clerk.addProduct();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable{
    Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        System.out.println("消费者开始消费产品");
        while (true){
            try {//处理wait（）抛出的异常
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                clerk.consumeProduct();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public class Testclass {
    public static void main(String[] args) {
      Clerk clerk=new Clerk();
      Productor p1=new Productor(clerk);
      Consumer c1=new Consumer(clerk);

      Thread T1=new Thread(p1,"生产者1");
      Thread T2=new Thread(c1,"消费者1");

      T1.start();
      T2.start();
    }
}

运行结果：
在这里插入图片描述

Jiashun Hao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 基础——尚硅谷学习笔记（含面试题） 2023年.zip
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多线程并发、netty、MySQL、MongoDB、Elasticsearch、Redis、HBASE
线程池管理多线程上传
01-15
使用线程池管理多线程上传，包含了文件拆分，文件分片多线程上传，单文件上传。多线程执行任务等待管理。拒绝直接new Thread创建新线程导致的诸多问题
java多线程应用实现方法
01-01
以前没有写笔记的习惯，现在慢慢的发现及时总结是多么的重要了，呵呵。虽然才大二，但是也快要毕业了，要加油了。 这一篇文章主要关于java多线程，主要还是以例子来驱动的。因为讲解多线程的书籍和文章已经很多了，所以我也不好意思多说，呵呵、大家可以去参考一些那些书籍。我这个文章主要关于实际的一些问题。同时也算是我以后复习的资料吧，。呵呵大家多多指教。 同时希望多结交一些技术上的朋友。谢谢。 —————————————————————————————————————————————————- java中的多线程 在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runabl
java多线程学习笔记02（csdn）————程序.pdf
12-01
java多线程学习笔记02（csdn）————程序
多线程文章目录
01-21
以下文章基本上保证真实可信，如有谬误欢迎指正； 同时很多内容来自个人有道笔记的摘抄，如果有不清不楚的地方还请见谅，可留言告知我完善相关内容； 也随时欢迎咨询和讨论~ Java多线程①——线程知识梳理 有助于新手初步了解线程相关的知识同时加深对基础的理解。 了解线程的状态、常用方法以及Thread、Runnable、Callable、Future、FutureTask这些基础概念和简单应用。 Java多线程②——多线程知识梳理 有助于了解线程池相关的知识、包括线程池执行逻辑、常用方法； 以及java为我们提供常用的线程池和任务调度ScheduledExecutorService以及工作窃取For
若依使用线程池的两种方式
最新发布
qq_50661854的博客
09-17 1446
若依使用线程池的两种方式
若依实现文件多线程批量上传案例
猿小白的博客
12-11 3986
若依实现文件多线程批量上传案例
ruoyi系统导入容易超时解决方案（redis+多线程）
www.小白
12-21 6408
对后端返回数据过慢进行的封装
多线性开发实例分享
IT小辉同学
05-23 816
愿梦想不被辜负，努力终将温柔回报
Java多线程:高并发下数据插入重复问题的解决办法
xiaoweids的博客
07-29 4002
5)即想提高效率不对方法添加synchronized，又想保证数据准确性，最后使用synchronized(siteId+uid)在Controller层加锁(保证了只有重复数据被加锁,在Controller使用的原因是因为事务会在Service调用完毕才被提交，我实验过在Service同步，150并发会出现2条重复数据，因为事务还没来得及提交)测试结果测试了3次150并发不到一秒的时间全部返回，结果1条登记成功，149条返回该作者已登记。因此确定了是多线程的并发导致了程序的判断逻辑失效。...
JAVA多线程学习笔记整理（csdn）————程序.pdf
12-01
JAVA多线程学习笔记整理（csdn）————程序
分布式系统知识点总结
qq_42902997的博客
11-04 1789
文章目录使用的资源汇总分布式系统定义计算机网络和分布式系统的区别使用分布式系统的原因在使用分布式系统时需要面对哪些问题并行系统和分布式系统的区别（parallel and distributed system）分布式系统举例分布式系统的一种定义是：一组独立的计算机，它们对外可以被视作单个系统，也就是说，即使有多台计算机，对用户也是完全隐藏的。给出一个例子，从这个角度来进行分析。中间件在分布式系统中的作用是什么解释(distribution) transparency 的含义，并举例说明不同类型的 trans
若依框架_05：接口汇总
Share_Li_98的博客
08-25 5963
若依框架接口汇总
线程池记录
Zzz258E的博客
03-14 1295
线程池 场景：添加设备到数据库的同时持久化设备数据到数据库 线程池配置文件 /** * 线程池配置文件 * * @author ：zhangYongJian * @date ：Created in 2022/1/5 15:04 * @version： [1.0.0] */ @Configuration public class ThreadPoolConfig { // 核心线程池大小 private final int corePoolSize = 2; //
一次以ruoyi框架为原型的技术知识栈整理
TT_4419的博客
07-16 1081
首先是。
多线程与高并发
chillaxjie的博客
07-20 263
创建线程的三种方式 1.extendds Thred类 .start() 2.implements Runnable接口 new Thread(new MyRun()).start(); 3.lambda表达式 new Thread(()->{}).start(); 4.线程池启动 Executors.newCachedThrad 线程常用方法 1.sleep 2.yield 退出线程 进入等待队列 3.join 在当前线程先执行其他线程 ...
如何使用线程池
m0_46159545的博客
08-19 1442
一、什么是线程池 ​ 类似于数据库连接池，为了能够复用线程、限制并发数以及减少上下文切换带来的资源消耗，使用池化的技术对线程进行管理。 二、线程池如何使用 ​ jdk给我们提供了Executor框架，来创建和使用线程池，架构图如下： ​ 主要使用的是Executor接口、ExecutorService接口、ThreadPoolExecuor类和Executors工具类。 1、Executor接口 ​ 此接口是一个函数式接口，只有一个待实现的方法，用来执行一项Runnable任务 2、Execut
【若依】线程池，分页工具,定时任务，aop日志,全局异常处理功能实现
qq_34844049的博客
10-26 2689
【若依】线程池，分页工具,定时任务，aop日志,全局异常处理功能实现
springboot中动态获取bean工具类
热门推荐
congge
12-27 1万+
在springmvc或者springboot的项目中，经常遇到需要获取其他的bean的类，从而使用该bean内部的一些方法，以供业务调用，我们知道，在spring项目中，某个被spring管理的类要调用其他的bean，有多种方式可以获取，比如通过注解注入，通过new出新对象得到，其实spring还提供了一种很好的方式，就是通过实现ApplicationContextAware这个接口，然后在全局各...
java 上传文件_JAVA学习笔记——fileUpload文件上传
05-17
文件上传是Web开发中常见的功能之一，Java中也提供了多种方式来实现文件上传。其中，一种常用的方式是通过Apache的commons-fileupload组件来实现文件上传。 以下是实现文件上传的步骤： 1.在pom.xml文件中添加以下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值