Java多线程

于 2020-12-01 19:50:01 发布
阅读量40 收藏
点赞数
分类专栏： java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39211828/article/details/110240731
版权

Java多线程

目录

前言

总结Java多线程的知识

一、Java线程的创建方式

1.继承Thread类

写一个类来继承Thread类，重写run方法。调用这个类实例的start方法会开启一个线程，来执行run方法。

public class Demo1 {

    public static void main(String[] args) {
        Thread thread = new T1();
        thread.start();
}
class T1 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(i);
        }
    }
}

2.实现Runnable接口

  1. 写一个类A实现Runnable接口，重写其run方法
  2. 写一个类B继承Thread类，将类A的对象传入类B的构造方法中，创建B类的对象
  3. 调用B对象的start方法，实际执行的是类A的run方法
public class Demo1 {

    public static void main(String[] args) {
        T2 t2 = new T2();
        Thread thread = new Thread(t2);
        thread.start();
}
class T2 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        for(int i=0;i<100;i++){
            System.out.println(i);
        }
    }
}

3.实现Callable接口

  1. 写一个类A实现Callable接口，重写call方法
  2. 将类A的对象传入B的构造方法，new一个FutureTask对象B
  3. 将B传入Thread类的构造方法new一个Thread类的对象C
  4. 调用C的start方法，开启一个线程执行call方法（call方法有返回值）
public class Demo1 {

    public static void main(String[] args) {
        T3 t3 = new T3();
        FutureTask<Integer> task = new FutureTask<>(t3);
        Thread thread = new Thread(task);
        thread.start();
        try {
            int sum = task.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class T3 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for(int i=0;i<10;i++){
            sum += i;
        }
        return sum;
    }
}

二、线程中断

调用interrupt方法使线程产生一个InterruptedException异常，进入catch块来进行处理。

public class Demo1 {

    public static void main(String[] args) {
        Thread thread = new T1();
        thread.start();
        for(int i=0;i<5;i++){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        thread.interrupt();
    }
}
class T1 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                System.out.println("线程自杀");
                return;
            }
            System.out.println(i);
        }
    }
}

在这里插入图片描述

三、线程同步

1、synchronized

①、同步代码块

synchronized(object)对括号中的对象加了一把锁，当线程持有这把锁的时候才能进入代码块中；某线程持有这把锁之后，其他线程不得获取这把锁。

//线程同步synchronized

public class Demo8 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1  同步代码块
        //格式：synchronized（锁对象）{
        //
        //
        //      }
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
            while (true) {
                synchronized (o) {
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }

                }
            }
        }
    }
}
②、同步方法

synchronized修饰的方法是同步方法。

  1. 实例方法：锁的是调用此方法的对象。
  2. 静态方法：锁的是这个类的class对象。
//线程同步synchronized
public class Demo9 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案2  同步方法
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {

            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        public synchronized boolean sale(){
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;

        }
    }
}

2、显式锁

package thread;

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


//同步代码块和同步方法都属于隐式锁
//线程同步lock

public class Demo10 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1   显示锁  Lock  子类 ReentrantLock

        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        //参数为true表示公平锁    默认是false 不是公平锁
        private Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true) {
                l.lock();
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }
                    l.unlock();
            }
        }
    }
}

四、公平锁与非公平锁

  1. 公平锁：先来先到，排队在前的线程先获得锁
  2. 非公平锁：争抢，所以等待的线程一起争抢锁

五、线程死锁

//警察say方法中的c.fun()执行要获取罪犯的对象锁
//罪犯say方法中的p.fun()执行要获取警察的对象锁
//相互等待，不释放锁，造成死锁
public class Demo11 {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }

    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.fun();
        }
        public synchronized void fun(){
            System.out.println("罪犯被放了，罪犯也放了人质");
        }
    }
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放了你");
            c.fun();
        }
        public synchronized void fun(){
            System.out.println("警察救了人质，但是罪犯跑了");
        }
    }
}

六、生产者与消费者

wait()是Object的方法，this.wait()的作用是用this来让当前线程休眠，此线程处于this的监视之下；
this.notifyAll()的作用是使得处于this监控下的线程都被唤醒。
下面这个例子中，两个线程在做完自己的事情后唤醒对方，自己休眠。

public class Demo12 {
    public static void main(String[] args) {
        //多线程通信    生产者与消费者问题
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }
    //厨师
    static class Cook extends Thread{
        private Food f;

        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if(i%2==0){
                    f.setNameAndTaste("老干妈小米粥","香辣味");
                }else {
                    f.setNameAndTaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务员
    static class Waiter extends Thread{
        private Food f;

        public Waiter(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;
        //true表示可以生产
        //boolean flag = true;
        public synchronized void setNameAndTaste(String name,String taste){
            //if(flag){
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
               // flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            //}

        }
        public synchronized void get(){
            //if(!flag){
                System.out.println("服务员端走的菜的名称是："+name+",味道是："+taste);
                //flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            //}
        }
    }
}

七、线程的状态

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的成为“运行”。
    线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得cpu 时间片后变为运行中状态（running）。
  3. 阻塞(BLOCKED)：表线程阻塞于锁。
  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
  5. 超时等待(TIME_WAITING)：该状态不同于WAITING，它可以在指定的时间内自行返回。
  6. 终止(Terminal)

在这里插入图片描述
内容出处

八、线程池

1.缓存线程池

获取方法：Executors.newCachedThreadPool()

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


public class Demo9 {
    public static void main(String[] args) {
        //线程池
        //创建线程
        //创建任务
        //执行任务
        //关闭线程

        //缓存线程池
        //无限制长度
        //任务加入后的执行流程
        //1判断线程池是否存在空闲线程  2存在则使用   3不存在则创建线程并使用

        //向线程池中加入新的任务
        ExecutorService service = Executors.newCachedThreadPool();
        //指挥线程池执行新的任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }

        };
        service.execute(task);
        service.execute(task);
        service.execute(task);

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

        service.execute(task);

    }
}

执行结果
执行结果

2.定长线程池

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


public class Demo9 {
    /*定长线程池
    长度是指定的线程池
    加入任务后的执行流程
        1 判断线程池是否存在空闲线程
        2 存在则使用
        3 不存在空闲线程  且线程池未满的情况下  则创建线程  并放入线程池中  然后使用
        4 不存在空闲线程  且线程池已满的情况下  则等待线程池的空闲线程
    **/
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        service.execute(task);
        service.execute(task);
        service.execute(task);
    }
}

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

3.单线程线程池

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

public class Demo9 {
    /*单线程线程池
    执行流程
        1 判断线程池的那个线程是否空闲
        2 空闲则使用
        3 不空闲则等待它空闲后再使用
    **/

    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        };
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(task);
        service.execute(task);
        service.execute(task);
    }
}

4.周期定长线程池

package thread;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo16 {
/*周期任务 定长线程池
执行流程
1 判断线程池是否存在空闲线程
2 存在则使用
3 不存在空闲线程 且线程池未满的情况下 则创建线程 并放入线程池中 然后使用
4 不存在空闲线程 且线程池已满的情况下 则等待线程池的空闲线程

        周期性任务执行时
                定时执行 当某个任务触发时  自动执行某任务
    **/
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        //定时执行一次
        //参数1：定时执行的任务
        //参数2：时长数字
        //参数3：2的时间单位    Timeunit的常量指定
       /* scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        },5, TimeUnit.SECONDS);      //5秒钟后执行*/

        /*
        周期性执行任务
            参数1：任务
            参数2：延迟时长数字（第一次在执行上面时间以后）
            参数3：周期时长数字（没隔多久执行一次）
            参数4：时长数字的单位
        * **/
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        },5,1,TimeUnit.SECONDS);
    }
}

总结

记录了Java多线程的一些用法
weixin_39211828
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最新尚硅谷周阳老师java面试视频
04-12
最新尚硅谷周阳老师java面试视频，2018
Java多线程详解及示例
最新发布
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
1.2019年周阳老师JVM·第一部分
大李出奇迹的博客
03-23 803
文章目录JVM架构图JVM体系结构概述类装载器 JVM架构图 常见的虚拟机面试题：主要是考淘宝的大神周志明写的那本书 JVM体系结构概述 扩展：JNI–java调用底层硬件，android还在用。 对于这张图，做一个知识链接，runtimeException是从运行时数据区抛出来的。 类装载器 ...
2.2019年周阳老师JVM·第二部分
大李出奇迹的博客
03-23 385
文章目录方法区栈堆·栈·方法区的交互关系 方法区 方法区（亮色）：所有线程共享，存在垃圾回收。 类的结构信息：模板。 类装载器，把class文件代表的Class装载到了方法区。 天上飞的是理念（方法区），落地的是实现（永久代，元空间）。 栈 栈管运行，堆管存储。 引入：当我们出异常的时候，是打印栈的运行轨迹，如下： 工作与学校的区别，如上。 java中，方法就可以理解为栈帧。一个一个...
2019年Java大厂面试题讲解（周阳） 之 JVM参数调优
轻狂书生FS的博客
09-22 2265
JVM参数调优前言JVM参数类型查看运行的Java程序，JVM参数是否开启，具体值为多少？题外话（坑题）查看JVM默认参数工作中常用的JVM基本配置参数查看堆内存打印JVM默认参数生活常用调优参数GC垃圾收集Full GC垃圾回收-XX:SurvivorRatio-XX:NewRatio（了解）-XX:MaxTenuringThreshold 前言 你说你做过JVM调优和参数配置，请问如何盘点查看JVM系统默认值 使用jps和jinfo进行查看 -Xms：初始堆空间 -Xmx：堆最大值 -Xss：栈空间
3.2019年周阳老师JVM·第三部分
大李出奇迹的博客
03-23 420
文章目录Heap堆结构简介heap堆new对象流程Transfervalue对象生命周期和GC永久代 Heap堆结构简介 堆包括三部分：新生代，老年代，元空间/永久代。 新生代包括：伊甸园区，幸存者0区，幸存者1区。 7是永久代，8是元空间。 物理上有2部分：新生+养老。 heap堆new对象流程 知识点：new一个对象，是new在了伊甸园区。 伊甸园区发生的GC是YGC。y是young的意...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
多线程源码JUC以及多线程和高并发
01-22
多线程源码JUC以及多线程和高并发 https://blog.csdn.net/u011488009 主要是根据 https://blog.csdn.net/u011488009/category_9678616.html 专栏来讲解的源码，都可以作为高并发的学习，练手用，主要是看这个源码，跟着敲出来，然后实现一遍就可以完美的实现这个原理的深入理解和支持。需要实战的投入
jvm思维导图
05-15
jvm思维导图，mindmaster打开，非常好用的思维导图画图工具
jvm调优思维脑图
12-25
总结了学习jvm调优的知识点，便于大家随时查看，快速串联思维。主要包括：java内存结构、堆内存的构成、堆内存参数调整、垃圾收集算法、垃圾收集器选择、JVM参数、java对象的内存分配过程、Tomcat调优并使用Jmeter评测、参考资料等。希望对大家学习jvm有帮助。
Java 基础知识储备.mmap
08-02
总结了Java开发过程中常用到的基础工具、实用技能。会一直更新，有了这些工具，开发时会事半功倍。包括字符串、数组、字典、算法、加密工具等常用开发中用得到的东西。
周阳老师SpringCloud2018思维导图（完整版）
06-12
内容为 “ 周阳老师SpringCloud2018思维导图（完整版） ”，本内容总共分为11章节的内容。网上有很多思维导图和视频上上的相比总是不完整，这个是完整的
JVM(2019.4.9)
赵小雷的博客
04-09 219
前言        本博客为个人复习时总结用，无商业目的，其大多数内容皆为博主整理所得，并非原创。侵删。 Java内存 程序计数器（Program Counter Register）：         程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，可以理解为是当前线程的行号指示...
[java基础复习]juc-尚硅谷周阳
qq_27637285的博客
07-30 447
买票问题复习 高内聚 低耦合前提下, 线程操作资源类 判断/干活/通知 多线程交互中, 必须要防止多线程的虚假唤醒(spurious wakeup), 也即(判断必须要用while, 不能用if). 注意标志位的修改和定位. IDEA中要生成自己的代码块的快捷键!!! 给IDEA增加自定义的代码模板: Idea代码模板和自定义代码模板的使用 精确通知顺序访问 package test; /* * 多线程之间按顺序调用，实现A->B->C * 三个线程启动，要求如下： * * AA打印
JVM 学习（脑图大纲）
Devin's Blog
05-11 523
JVM剖析1 class1.1 constantpool1.1.1 classfields1.1.2 methods1.1.3 constant1.2 Operandstack1.3  2 data2.1 heap3 对象3.1 对象创建过程3.1.1 对分配内存空间的动作进行同步处理3.1.2 内存分配的动作按照线程划分在不同的空间之中进行参数：-XX：+/-UseTLAB3.2 对象的内存布局...
JVM思维导图
sinat_38036426的博客
05-15 1014
Java多线程深度解析
"Java多线程全套教程，涵盖了从基础到高级的多线程知识，包括线程的概念、创建方式、CPU调度以及线程池的使用。" Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高程序的运行效率。在深入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值