多线程基础

最新推荐文章于 2023-05-29 12:36:13 发布
最新推荐文章于 2023-05-29 12:36:13 发布
阅读量166 收藏
点赞数
分类专栏： JavaStudy2020 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45629145/article/details/110116288
版权

多线程

1、概念

  • 进程是一个应用程序。
  • 线程是一个进程中的一个执行单元
  • 一个进程可以启动多个线程
  • 进程之间内存独立不共享
  • 在java语言中，线程之间 ，堆内存和方法区是共享的。栈内存是独立的，一个线程一个栈。
    在这里插入图片描述

实现多线程

1、方式一，编写一个类，继承java.lang.Thread，重写run方法
例如：

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("MyThread"+i);
        }
    }
}
 

public class Test01{
   public static void main(String[] args) {
       MyThread myThread = new MyThread();
       myThread.start();
       for (int i = 0; i < 1000; i++) {
           System.out.println("主线程"+i);
       }
   }
}

运行结果：
在这里插入图片描述
2、方式二，实现Runable接口

public class MyThread02 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyThread02"+i);
        }
    }
}

@Test
    public void t2() {
        MyThread02 myThread02 = new MyThread02();
        Thread t1 = new Thread(myThread02);
        t1.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程"+i);
        }
    }

结果：
在这里插入图片描述
3、采用 匿名内部类方式

@Test
    public void t3() {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("匿名内部类"+i);
                }
            }
        });
        t1.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程"+i);
        }
    }

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

线程生命周期

在这里插入图片描述

常用操作

1、获取当前线程对象的信息

  • 获取线程的名字：getName()
  • 设置线程的名字：setName()
  • 获取当前线程：Thread.currentThrend();

2、sleep（）方法

  • 静态方法：Thread.sleep(1000)；
  • 参数是毫秒
  • 作用：让当前线程进入休眠，进入“阻塞状态”，放弃占用CPU时间片，让给其他线程使用
    面试题：
public class MyThread03 {
    public static void main(String[] args) {
        Thread t1 = new T1();
        t1.start();
        try {
            //因为sleep是静态方法所以此处其实是Thread.sleep是当前主线程睡眠进入阻塞状态
            t1.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello world!");
    }
}

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

结果：hello world! 隔了5秒后输出
在这里插入图片描述

3、interrupt（）方法：中断线程的睡眠，唤醒sleep的线程，利用异常的方式。

4、终止线程推荐方法：

public class MyThread04 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        t2.setName("t2");
        t2.start();
        try {
            //主线程sleep5秒
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //5秒之后就会停止T2线程
        t2.run = false;
    }
}

class T2 extends Thread {
    boolean run = true;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(run) {
                System.out.println(Thread.currentThread() + "-->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                //这里会终止线程,比如可以在终止的时候保存没保存的文件
                return;
            }
        }
    }
}

在这里插入图片描述

5、线程调度

1、常见的线程调度模型

  • 抢占式调度模型：线程的优先级越高，抢到的CPU时间的概率就搞一些。（Java采用的就是）
  • 均分式调度模型：平均分配CPU时间片，每个线程占用的时间片长度一样。

2、线程调度的方法

  • setPriority(int newPriority) 更改线程优先级
  • getPriority(）：获取线程优先级
  • 最低1，最高10，默认5
  • 静态方法：yield()：暂停当前执行的线程，回到就绪状态，让出时间片，执行其他线程。不是阻塞
  • 实例方法：void join() 合并线程

6、线程安全

1、数据在多线程并发的环境下存在安全问题的条件

  • 多线程并发
  • 存在数据共享
  • 共享数据有修改的行为

2、解决线程安全

  • 线程同步机制synchronized在这里插入图片描述
    3、死锁
public class MyThread05 {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        T3 t3 = new T3(o1,o2);
        T4 t4 = new T4(o1,o2);
        t3.start();
        t4.start();
    }
}

class T3 extends Thread {
    private Object o1;
    private Object o2;

    public T3(Object o1,Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2) {

            }
        }
    }
}

class T4 extends Thread {
    private Object o1;
    private Object o2;

    public T4(Object o1,Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1) {

            }
        }
    }
}

开发中避免使用synchronzed嵌套

在开发中如何解决线程安全问题

1、尽量使用局部变量代替“实例变量和静态变量”
2、如果必须是实例变量，那么可以考虑创建多个对象，这样的话实例变量的内存就不是共享的。
3、如果不能使用局部变量，那就只能选择synchronized。

守护线程

1、Java中线程分为两大类

  • 用户线程
  • 守护线程（后台线程），比如垃圾回收线程（守护线程）
    • 特点：一般守护线程就是一个死循环，所有的用户线程只要结束，守护线程自动结束；（主线程main方法是一个用户线程）

2、实现

public final void setDaemon(boolean on)
将此线程标记为daemon线程或用户线程。 当运行的唯一线程都是守护进程线程时，Java虚拟机将退出。
线程启动前必须调用此方法。

参数
on - 如果 true ，将此线程标记为守护线程

定时器

1、作用

  • 间隔特定的时间，执行特定的程序

2、实现

  • 利用sleep方法
  • java.util.Timer
  • 实际开发中，spring框架提供SpringTask框架

3、coding

public class MyTimeTask {
    public static void main(String[] args) throws ParseException {
        //设置起始时间，将给定的时间转成Date对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse("2020-11-26 16:30:50");
        //创建定时器对象
        Timer timer = new Timer();
        /*
        schedule(TimerTask task, Date firstTime, long period)
        从指定的时间开始 ，对指定的任务执行重复的固定延迟执行 。
         */
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                Date now = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String format = sdf.format(now);
                System.out.println(format+"  备份了");
            }
        },date,1000*5);
    }
}

在这里插入图片描述

实现多线程的第三种方式实现Callable接口（java8新特性）

该方式可以获取线程的返回值

public class MyCallableThread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        创建一个FutureTask，该任务将在运行时执行给定的Callable。 参数： 可调用–可调用任务
         */
        FutureTask futureTask = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {
                System.out.println(Thread.currentThread()+"执行");
                Thread.sleep(5000);
                System.out.println(Thread.currentThread()+"结束");
                return "线程返回的结果";
            }
        });
        Thread t = new Thread(futureTask);
        t.start();
        //这一步会导致主线程阻塞，因为主线程要获取线程的返回结果，要等该线程执行完毕才能接着执行自己的内容；
        futureTask.get();
        System.out.println("主线程。。。");
    }
}

在这里插入图片描述

Object中的wait和notify方法

1、不是线程中的方法，是Java中任何一个对象都有的
2、wait（）方法作用

  • Object o = new Object(); o. wait()；
  • 让正在o对象活动的线程进入等待状态，无限期等直到被唤醒。（会让当前线程进入等待状态）
  • 调用notify（）方法，将进入等待状态的线程唤醒。

生产者消费者代码演示：

public class ProductConsumer {
    public static void main(String[] args) {
        List list = new ArrayList();
        Product product = new Product(list);
        Consumer consumer = new Consumer(list);
        Thread t1 = new Thread(product);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();
    }
}

//生产者
class Product implements Runnable {
    //仓库
    private List list;

    public Product(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //不停的生产对象
        while (true) {
            //将共享对象锁住
            synchronized (list) {
                if (list.size() > 0) {
                    try {
                        //如果已经有产品了，就停止生产，等待消费者消费
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //没有产品就 生产
                Object o = new Object();
                list.add(o);
                System.out.println("生产者生产中。。。"+o);
                list.notifyAll(); //唤醒所有线程，但并不释放锁
            }
        }
    }
}

//消费者
class Consumer implements Runnable {
    //仓库
    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //不停的消费产品
        while (true) {
            synchronized (list) {
                if (list.size() == 0) {
                    //如果没有产品了，就等待生产
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果有产品就消费
                Object remove = list.remove(0);
                System.out.println("消费者消费中。。。"+remove);
                //唤醒所有线程，不释放锁
                list.notifyAll();
            }
        }
    }
}

在这里插入图片描述

练习

在这里插入图片描述

public class Product implements Runnable{
    private MyEx num;

    public Product(MyEx num) {
        this.num = num;
    }

    @Override
    public void run() {
        while (num.num < 100) {
            synchronized (num) {
                if (num.num % 2 == 0) {
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName()+"-->"+num.num++);
                num.notifyAll();
            }
        }
    }
}

public class Consumer implements Runnable{
    private MyEx num;

    public Consumer(MyEx num) {
        this.num = num;
    }

    @Override
    public void run() {
        while (num.num < 100) {
            synchronized (num) {
                if (num.num % 2 != 0) {
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName()+"-->"+num.num++);
                num.notifyAll();
            }
        }
    }
}

public class MyEx {
    int num = 1;
    public static void main(String[] args) {
        MyEx myEx = new MyEx();
        Product product = new Product(myEx);
        Consumer consumer = new Consumer(myEx);
        Thread t1 = new Thread(product);
        t1.setName("t1");
        Thread t2 = new Thread(consumer);
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}

在这里插入图片描述

@小匠
关注
专栏目录
看一道关于Thread.sleep()方法的面试题
pipizhen_的博客
07-24 555
看一个Thread.sleep()方法的面试题： 代码： public class Test06 { public static void main(String[] args) { // 创建线程对象 Thread t = new Thread(new MyRun06()); t.setName("t"); t.start(); try { // 问题：这行代码会让t线程睡眠5秒钟吗？
理解.NET中Thread.Sleep()方法(C#)
jhycjhyc的专栏
01-03 5万+
using System using System.Threading; namespace ThreadTest   {  public class A     {         public static void B()         {             while (true)             {                 Console.Wr
Thread.sleep( )线程休眠的优化写法
阿水的博客
05-29 1803
TimeUnit.SECONDS.sleep(10)在可读性和代码清晰性方面略胜一筹，而Thread.sleep(10 * 1000)则需要手动进行单位转换，并且可读性稍差。两者在功能上是等效的，选择使用哪种方式取决于个人偏好和代码风格。
线程的睡眠与唤醒Thread.sleep()与interrput()
u014573304的博客
05-11 5043
Thread.sleep()方法 当我们需要使一个线程进入睡眠的时候，那么我们就需要使用到sleep()方法。sleep()方法是一个静态方法,调用时，我们只需要直接使用 “类名.sleep()” 就可以调用该方法。 Thread.sleep(long millis)方法的参数是一个long类型的毫秒数 代码效果如下: public class Test{ public static void main (String[] args){ //使main线程睡眠5秒后打印Hello World
线程(Thread)Sleep
sudo 专栏
12-28 1001
我们可能经常会用到 Thread.Sleep 函数来使线程挂起一段时间。那么你有没有正确的理解这个函数的用法呢？思考下面这两个问题：假设现在是 2009-12-28 12:00:00.000，如果我调用一下 Thread.Sleep(1000) ，在 2009-12-28 12:00:01.000 的时候，这个线程会 不会被唤醒？某人的代码中用了一句看似莫明其妙的话：T
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
多线程基础部分.md，学习代码
最新发布
06-21
我们将围绕标题“多线程基础部分”展开，结合描述和标签，重点关注Java中的多线程、软件设计以及并发编程的相关概念。 首先，让我们理解什么是多线程。在计算机科学中，线程是程序执行的基本单位，一个进程可以包含...
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
java多线程基础知识
01-25
Java多线程基础知识 Java多线程基础知识是Java编程语言中的一项重要技术，用于提高程序的执行效率和响应速度。在这里，我们将详细介绍Java多线程基础知识的相关概念和技术。 一、程序、进程和线程 程序（Program...
多线程-Thread类的常用方法及使用场景
weixin_42740540的博客
04-12 618
众所周知，操作线程就必须熟读线程的API方法，万一你开个多线程刹不住车就歇菜了，下面就介绍一些API基本用法。包括sleep，join，yield，interrupt。 sleep，让当前线程睡一会。原生用法Thread.sleep(毫秒)，会抛出一个打断的异常；此方法可防止CPU100%的问题，如果你代码中有轮训机制，就会体验到。while(true) 中加上一个sleep，CPU至少会减低80%消耗。一般我们采用自制工具类。因为JUC中支持改玩意，不需要每次去catch异常 public clas
Java中关于Thread.sleep()与 线程对象.sleep()的思考
weixin_43114954的博客
02-02 2398
前言：java中Thread线程类中的sleep（）查看API文档如下： static void sleep(longmillis) 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。 static void sleep(longmillis, intnanos) 导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），这取决于系统定时器和调度器的精度和准确性。 得知该方法为静态方法，...
yield的使用
weixin_30696427的博客
02-27 197
通过使用 yield 定义迭代器，可在实现自定义集合类型的IEnumerable和IEnumerator模式时无需其他显式类（无需通过new List-再retuenIEnumerable） yield是一个语法糖 看msdn 的解释总是让人感觉生硬难懂。其实yield关键字很好理解。首先我们对于性质有个了解。yield是一个语法糖。既然yield是在C#中的一个语法糖，那么就说明y...
关于多线程中的Thread.sleep方法以及面试相关
m0_47739580的博客
06-30 1940
多线程中sleep方法详解，以及与sleep有关的面试题
Thread之sleep方法
热门推荐
feigeswjtu的专栏
12-03 12万+
为什么要用sleep，主要是为了暂停当前线程，把cpu片段让出给其他线程，减缓当前线程的执行。 方法的定义: public static void sleep(long millis); public static native void sleep(long millis) throws InterruptedException;通过定义可以看出sleep方法是本地方法，通过系统调用暂停
Thread.sleep(1000)
weixin_30786657的博客
02-16 3513
public class Wait { public static void main(String[] args) { System.out.println(System.currentTimeMillis()); //程序暂停1000ms try { Thread....
Thread的sleep()方法
qq_37555579的博客
08-06 2489
Thread的sleep()方法
Java Thread之Sleep()使用方法总结
weixiaohuai的博客
11-12 10万+
一、API简介 Thread.sleep()是Thread类的一个静态方法，使当前线程休眠，进入阻塞状态（暂停执行），如果线程在睡眠状态被中断，将会抛出IterruptedException中断异常。。主要方法如下： 【a】sleep(long millis)  线程睡眠 millis 毫秒 【b】sleep(long millis, int nanos)  线程睡眠 millis 毫秒 +...
C#多线程基础解析与应用
"C#多线程基础教程" 在C#编程中，多线程是一个重要的概念，它允许程序同时执行多个任务，从而充分利用系统资源，提高程序效率。本教程将介绍C#中如何创建和管理多线程。 一、线程的基本概念 线程是操作系统分配...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值