Java多线程

最新推荐文章于 2024-05-16 13:19:04 发布
最新推荐文章于 2024-05-16 13:19:04 发布
阅读量1.4k 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hashmapdemo/article/details/124289461
版权

目录

1、多线程技术概述

2、多线程的实现

3、Thread类详解

4、线程的休眠、阻塞及中断

5、守护线程

6、线程安全问题（使用锁）

7、多线程通信（生产者与消费者）

8、线程的六种状态

9、线程池

一、多线程技术概述

1、线程与进程

进程：

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程：

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程

线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

2、线程调度

分时调度：

所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

抢占式调度：

优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而CPU在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高

3、同步与异步

同步：

排队执行，效率低但是安全

异步：

同时执行，效率高但是数据不安全

4、并发与并行

并发：

指两个或多个事件在同一个时间段内发生

并行：

指两个或多个事件在同一时刻发生（同时发生）

二、多线程的实现

1、继承Thread

在子线程类名后继承Thread即可

子线程：

public class MyThread entends Thread{
    
    @Oveeride
    public void run(){
        //这里的代码，就是一条新的执行路径
        //这个执行路径的启动方式，不是调用run方法，而是通过thread对象的start()方法来启动任务
        for(int i = 0;i < 10;i++){
            System.out.println(i);
        }
    }
}

run方法就是线程要执行的方法

主线程：

public class Demo{
    
    public static void main(String[] args){
        MyThread m = new MyThread();
        m.start();
    }
}

2、实现Runnable

实现Runnable接口一样可以实现多线程

子线程：

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        //线程的任务
        for(int i = 0;i < 10;i++){
            System.out.println(i);
        }
    }
}

主线程：

public class Demo{
    
    public static void main(String[] args){
        //实现Runnable
        //1、 创建一个任务对象
        MyRunnable r = new MyRunnable;
        //2、 创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        //3、 执行这个线程
        t.start();
    }
}

实现Runnable 与 继承Thread 相比有如下优势：

1、通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况

2、可以避免单继承所带来的局限性

3、任务与线程本身是分离的，提高了程序的健壮性

4、线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

三、Thread类详解

1、重要方法：

getId():        返回此Thread的标识符

getName():        返回此线程的名称

set/getPriority():        更改/返回此线程的优先级

        字段：MAX_PRIORITY：线程可以拥有的最大优先级

                   MIN_PRIORITY： 线程可以拥有的最低优先级

                   NORM_PRIORITY：分配给线程的默认优先级

start()：        导致此线程开始执行，Java虚拟机调用此线程的run方法

setDaemon：        将此线程标记为daemon线程或用户线程

2、设置和获取线程名称

public static void main(String[] args){
    //获取线程名称：getName()
    System.out.println(Thread.currentThread().getName());
    //为线程设置名称
    new Thread(new Myrunnable(),name:"新线程名称").start();
}

static class MyRunnable implements Runnable{

    @Override
    public void run(){
        //currentThread()代表当前正在运行的线程
        System.out.println(Thread.currentThread().getName());
    }
}

四、线程的休眠、阻塞及中断

1、线程休眠sleep

使用方法：

public static void main(String[] args) throws InterruptedException{
    //线程的休眠 sleep
    for(int i = 0;i < 10;i++){
        System.out.println(i);
        //线程的休眠方法，单位为毫秒，即每当线程运行到此都要休息1秒再继续运行
        Thread.sleep(1000);
    }
}

 InterruptedException异常：

线程在等待，休眠或以其他方式占用时抛出，并且线程在活动之前或期间被中断

2、线程的中断

可使用线程中断来关闭线程：

public static void main(String[] args) throws InterruptedException{
    //线程中断
    //一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定
    Thread t1 = new Thread(new MyRunnable());
    t1.start();
    for(int i = 0;i < 10;i++){
        System.out.println(i);
    }

    //给线程t1添加中断标记，使线程产生InterruptedException异常
    t1.interrupt();
}

以下方法都可产生InterruptedException异常：

wait()        wait(long)        wait(long,int)        sleep(long)        interrupt()        interrupted()

线程MyRunnable:

static class MyRunnable implements Runnable{

    @Override
    public void run(){
        for(int i = 0;i < 10;i++){
            System.out.println(i);
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                //关闭线程
                return;        
            }
        }
    }
}

五、守护线程

线程：        分为守护线程和用户线程

用户线程：

当一个进程不包含任何的存活的用户线程时，进程结束

守护线程：

守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡

注：直接创建的线程都是用户线程

设置守护线程：

在启动之前设置

Thread t1 = new Thread(new MyRunnable());
//设置t1为守护线程
t1.setDaemon(true);

六、线程安全问题（使用锁）

多个线程同时执行去争抢一个数据的情况下

1、同步代码块

格式：synchronized(锁对象)

           锁对象可以是任意对象

实例：

static class Ticket implements Runnable{
    //票数
    private int count = 10;
    private Object o = new Object();
    @Override
    public void run(){
    
        while(true){
            //上锁
            synchronized(o){
                if(count > 0){
                    //卖票
                    System.out.println("正在准备卖票");
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票:"+count);
                }else{
                    break;
                }
            }
         }
    }
}

注：多个线程看同一把锁才能排队

public static void main(String[] args){
    
    Runnable run = new Ticket();
    new Thread(run).start();
    new Thread(run).start();
    new Thread(run).start();
}

2、同步方法

给方法添加synchronized修饰符，在执行此方法时会排队执行

public synchronized 返回类型 方法名(){
}

在方法内部操作的this是谁锁对象就是谁

如果方法被静态修饰锁对象就是类名.class

注：

new Thread(new Ticket()).start();
new Thread(new Ticket()).start();
new Thread(new Ticket()).start();

如果三个线程建立三个对象则不排队（不是同一把锁）

如果同步代码块与同步方法同时存在且使用同一把锁，则线程执行同步代码块时其他线程无法执行同步方法，同理，多个同步方法使用同一把锁，则其中一个执行其他方法也都执行不了

3、显示锁Lock

同步代码块 和 同步方法都属于隐式锁

使用方法：

通过显示锁Lock子类ReentrantLock创建锁对象

实例：

static class Ticket implements Runnable{
    //创建显示锁l
    Lock l = new ReentrantLock();
    @Override
    public void run(){
        while(true){
            //上锁
            l.lock();
                ...
            //解锁
            l.unlock();
        }
    }
}

4、公平锁 与 非公平锁

公平锁：线程排队，先来先到

非公平锁：线程争抢执行

公平锁的实现：

//显示锁l：fair参数为true 就表示是公平锁
private Lock l = new ReentrantLock(true);

七、多线程通信（生产者与消费者）

使用方法：

wait()：        导致当前线程等待它被唤醒，通常是通知或中断

notify()：        唤醒正在此对象监视器上等待的单个线程

                       随机唤醒一个调用此对象睡着的线程

notifyAll()：        唤醒等待此对象监视器的所有线程

其他线程想要唤醒线程必须调用使此线程睡着的对象的唤醒方法

实例（生产者与消费者）：

public class Demo{
    //生产者与消费者
    
    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.setNameAndSaste("老干妈炒饭","香辣味");
                }else{
                    f.setNameAndSaste("煎饼果子","甜辣味");
                }
             }
        }
    }

    //服务生
    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++){
                f.get();
            }
        }
    }

    //食物
    static class Food{
        private String Name;
        private String taste;

        //true 表示可以生产
        private boolean flag = true;
        
        public synchronized void setNameSaste(String name,String taste){
            if(flag){
                this.name = name;
                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

        尚未启动的线程的线程状态；

2、RUNNABLE

        可运行线程的线程状态；

3、BLOCKED

        线程的线程状态被阻塞等待监视器锁定；

4、WAITING

        等待线程的线程状态；

5、TIMED_WAITING

        具有指定等待时间的等待线程的线程状态；

6、TERMINATED

        终止线程的线程状态；

九、线程池

线程池 Executors

        如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间，线程池就是容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

降低资源消耗

提高响应速度

提高线程的可管理性

Java中的四种线程池 .ExecutorService

1、缓存线程池

长度无限制

执行流程:

1. 判断线程池是否存在空闲线程

2. 存在则使用

3. 不存在,则创建线程 并放入线程池, 然后使用

使用过程：

//创建缓存线程池
ExecutorService service = Executors.newCachedThreadPool();

//向线程池中 加入 新的任务
service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

2、定长线程池

长度是指定的数值

 执行流程:

1. 判断线程池是否存在空闲线程

2. 存在则使用

3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用

4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

使用过程：

//创建长度为2的定长线程池，不允许再扩容
ExecutorService service = Executors.newFixedThreadPool(2);

service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

3、单线程线程池

效果与定长线程池创建时传入数值1效果一致

执行流程:

1. 判断线程池 的那个线程 是否空闲

2. 空闲则使用

4. 不空闲,则等待 池中的单个线程空闲后 使用 

使用过程：

ExecutorService service = Executors.newSingleThreadExecutor();

service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

4、周期性任务定长线程池

执行流程:

1. 判断线程池是否存在空闲线程

2. 存在则使用

3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用

4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

周期性任务执行时: 定时执行, 当某个时机触发时, 自动执行某任务

使用过程：

/**
* 定时执行（执行一次）
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位（TimeUnit的常量指定）
*/
service.schedule(new Runnable() {

    @Override
    public void run() {
        System.out.println("俩人相视一笑~ 嘿嘿嘿");
    }
},5,TimeUnit.SECONDS);//seconds代表秒


/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)，第一次执行在什么时间以后
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println("俩人相视一笑~ 嘿嘿嘿");
    }
},5,2,TimeUnit.SECONDS);

}

hashmapdemo1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
new Thread(new Runnable(){})
热门推荐
麦七的博客
08-10 3万+
JAVA是面向对象的，也就是说，对于一个方法等，它需要什么类型的对象，只要传入就可以了。 像这里，Thread类的构造方法中，需要一个实现了Runnable接口的对象，而new就是生成了个Runnable接口下的一个实例对象。 同等与这种写法，实例化了一个Runnable接口子类的实例 Thread t=new Thread(new MyRunnable()); public class MyRunnable implements Runnable{ @Override public void run(
Java中Thread类的基本用法
m0_67683346的博客
08-19 5835
Java中的Thread类的基本使用
Java多线程（二）：线程的常用方法和状态_&quot；java的new thread (thread, &quot；窗口1 &quot；)(1)
最新发布
2401_84975387的博客
05-16 322
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取 TimeUnit.DAYS.sleep(1);//天 TimeUnit.HOURS.sleep(1);//⼩时 TimeUnit.MINUTES.sleep(1);//分 TimeUnit.SEC
new Thread() 的危害
qq_34253002的博客
09-07 5693
1）开销大 每次new Thread() 都会创建新的对象，开销较大，无法复用增加垃圾回收的负担。 2）管理困难 每个newThread() 都是独立的个体，无法有效的管控，无限制创建相互竞争，可能导致oom或者核心业务线程阻塞。 3）功能单一 无法定时执行，中断线程等功能。
线程系列二：Thread构造函数
sys的博客
12-13 1606
线程系列二：Thread构造函数 文章目录线程系列二：Thread构造函数前言一、new Thread二、与jVM1.与内存的关系2.线程创建的数量三、守护线程 前言 在我们开始学线程的时候新建一个线程用的什么？new Thread()相信大家都很熟悉，不知道大家有没有深入理解过这个函数 一、new Thread 有一下几个知识点: new Thread(“t1”) 可以传入一个参数作为线程的名字，如果没有会默以"Thread-"作为前缀递增 在线程是new状态时可以修改线程名字其他状态将不能修
Java学习（9）—— 多线程
Archer__13的博客
11-01 828
多线程的创建
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
【多线程】Thread 类及常见方法
m0_60494863的博客
05-14 4955
1.Thread 类 在Java标准库中，提供有一个Thread,来表示/操作线程。 Thread 类也可以视为Java 标准库提供的API。 创建好的 Thread 实例，其实和操作系统中的线程是一一对应的关系。 操作系统，提供了一组关于线程API（C语言风格），Java对于这组API进一步封装了，就成了Thread类 2.创建线程 2.1继承Thread 类 通过Thread 类创建线程，最基本的做法就是创建子类，继承自Thread ，并且重写run方法 （1）继承Thread 来创建一
线程学习
qq_31579261的博客
05-07 1598
一、线程的创建： 用Java创建一个线程是这样的： Thread thread = new Thread（）; 要启动Java线程，您将调用其start()方法，如下所示： thread.start（）; 此示例未指定要执行的线程的任何代码。线程启动后会立即再次停止。 二、指定线程执行代码: 1、创建Thread子类，覆盖run()方法； package...
线程（1）
weixin_60475929的博客
01-25 400
线程 线程（thread）是一个程序内部的一条执行路径 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径 程序中只有一条执行路径，那么这个程序就是单线程的程序 多线程 概述 多线程是指从软硬件上实现多条执行流程的技术 多线程的作用 多线程的创建 方式一：继承Thread类 Thread类： Java是通过java.lang.Thread类来代表线程 按照面向对象的思想，Thread类应该提供多线程的方式 方案： 缺点； 线程类已...
并发——线程池优于new Thread
GSON的博客
06-12 1220
每次new Thread的时候，都会创建一个单线程，但是，我们在项目中基本都是使用线程池，本文主要整理了线程和线程池的优缺点。
Java线程
m0_56188609的博客
02-22 2135
两个线程同时运行均要使用CPU，While(ture)为死循环，两个线程均需要不断使用CPU，而两个线程大量使用CPU会造成CPU占用率达到100%，其他代码、操作系统其他程序就会暂停卡住。因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码（从使用CPU到不适用CPU称之为线程的一次上下文切换）当然它的底层是否由多个核心对这两个线程并行执行还是一个核心对它们并发处理，包括打印的前后顺序是不由我们控制的。（快照：只能查看某一刻） 查看某个 Java 进程（PID）的所有线程状态。
Thread 类的基本用法
m0_62055442的博客
01-07 350
Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。
Java多线程学习(二)---线程创建方式
weixin_33912246的博客
08-12 175
线程创建方式 摘要： 1. 通过继承Thread类来创建并启动多线程的方式 2. 通过实现Runnable接口来创建并启动线程的方式 3. 通过实现Callable接口来创建并启动线程的方式 4. 总结Java中创建线程的方式，比较各自优势和区别 一、继承Thread类创建线程类 1.1 继承Thread类创建线程步骤 Java使用Thread类代表线程，所有的线程对象都必须是Th...
创建线程的三种方式：
m0_62404386的博客
08-10 620
创建线程的三种方式

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值