JAVA学习【多线程】

最新推荐文章于 2023-06-14 17:20:14 发布
最新推荐文章于 2023-06-14 17:20:14 发布
阅读量226 收藏
点赞数
分类专栏： JAVA笔记 文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65541646/article/details/129930998
版权

多线程学习

一、线程的概念
1、程序、进程、线程的概念

①、程序：是为完成特定任务，用某种语言编写的一种指令集合。即指一段静态代码，静态对象。
②、进程：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。----生命周期。

  • 如运行中的QQ、Mp3播放器。
  • 进程时动态的，而程序时静态的。
  • 进程作为资源分配的单位，系统在运行时会为每个不同的进程分配内存空间。
    ③、线程：进程可进一步细化为线程，是程序内部的一条执行路径。
  • 若一个进程同一时间并行执行多个线程，就是支持多线程的。
  • 线程作为执行和调度的单位，每一个线程都有单独的运行栈和程序计数器（pc），线程切换的开销小。
  • 一个进程的多个线程共享相同的内存单元/内存地址空间->他们从同一堆中分配对象。
    可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
2、并行和并发的概念

2.1、并发：同一时刻只能有一条指令执行，但多个进程指令被快速轮换，使得在整体上看见是多个进程同时执行的结果。
2.2、并行：并行指在同一时刻，有多条指令在多个处理器上执行。

二、线程的创建
1、继承Thread类

步骤：

  1. 继承Thread类
  2. 重写run()方法
  3. 创建继承了Thread类的子类对象
  4. 使用子类对象调用start()方法

注意：
在调用start()方法时，不能让已经实行过start()的线程再次调用，会报异常，需要再去创建一个线程对象，通过这个对象再start。如果去直接调用run()方法，不会启动线程，只会在main()方法中执行完。

package 多线程;

/**
 * @author shkstart
 * @create 2023-03-28 19:20
 */

//实现多线程的第一种方法

public class
ThreadTest1 {
    public static void main(String[] args) {
        //3.创建这个继承了Thead类的对象
        Test t1 = new Test();
        //4. 引用对象.start
        t1.start();//①、启动当前线程 ②、调用当前线程的run()
        //问题二：在启动一个线程，遍历100以内的偶数。
        //不能让已经start()的线程去执行，会报异常
        //在创建一个新的对象，然后调用start（）
        Test t2 = new Test();
        t2.start();
        for (int i = 0; i < 100; i++) {
            if (i%2==0)
                System.out.println(i+"==========main==============");
        }

            /***
             * 两个线程，一个遍历100以内的偶数，一个遍历100以内的奇数
             * 用匿名内部类
             */
            new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        if (i%2==0)
                            System.out.println(i+"==========main==============");
                    }
                }
            }.start();

            new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        if (i%2!=0)
                            System.out.println(i+"==========main==============");
                    }

                }
            }.start();

    }
}
//1.继承Thread类
class Test extends Thread{
    //2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i+"========Test==============");
            }
        }
    }
}
2、实现Runnable接口

步骤：

  1. 创建一个类继承Runnable接口
  2. 重写接口中的run()方法
  3. 创建该类的对象
  4. 创建一个Thread对象，将实现类的引用对象作为参数丢入Thread对象的构造器中
  5. 通过Thread对象调用start()方法启动多线程

在实际开发中，两种创建方式的比较：
在开发中，优先选择使用实现的方式去创建多线程
原因：

    1. 因为JAVA中只能单继承，如果继承了Thread类就无法继承别的类
    1. 实现的方法更适合处理多个线程共享同一份数据的情况

联系，我们发现Thread类也实现了Runnable接口
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中
目前两种方式，想要启动线程，都是调用Thread类中的start()

class TestRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class  RunnableTest {
    public static void main(String[] args) {
        TestRunnable testRunnable = new TestRunnable();
        Thread thread = new Thread(testRunnable);//通过源码发现，调用了Runnable类型的target的run
        thread.start();
    }
}
3、实现Callable接口

步骤：

  1. 创建一个实现类继承Callable接口
  2. 重写Callable接口中的call()方法
  3. 创建实现类的对象
  4. 创建FutureTask对象，并将实现类的对象作为参数丢入FutureTask对象的构造器中。
  5. 用Thread类启动线程。new Thread(FutureTask的对象).start();
  6. 如果想知道call()方法的返回值，就用FutureTask的对象调用get()方法。

如何理解Callable接口实现多线程比Runnable实现多线程更加强大？

  • call()方法可以有返回值。
  • Callable方法可以抛出异常。
  • Callable接口可以使用泛型。
class A implements Callable {


    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i%2==0){
                sum+=i;
                System.out.println(i);
            }
        }
        return sum;//这里输出的sum是Integer类型的，因为方法是Object类型的
    }
}
public class CallableTest {
    public static void main(String[] args) {
        //创建futureTask对象，将Callable的实现类作为参数丢入FutureTask的构造器中
        A a = new A();
        FutureTask futureTask = new FutureTask<>(a);
        //启动线程
        new Thread(futureTask).start();

        //用get方法，获得实现类中call()方法的返回值
        try {
            Object o = futureTask.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }

    }
}
4、创建线程池

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具，我们需要时就能直接使用，而不用等到它创建出来。

好处：

  1. 提高响应速度(减少了创建新线程的时间)(重复利用线程池中线程，不需要每次都创建
  2. 降低资源消耗
  3. 便于线程管理

corePoolSize: 核心池的大小
maximumPoolSize: 最大线程数
keepALiveTime: 线程没有任务时最多保持多长时间后会终止

class Numbers implements Runnable{

    @Override
    public void run() {
            for (int i = 0; i <= 100; i++) {
                if (i % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
    }
}
public class TreadPoolTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new Numbers());//适用于Runnable接口
//        service.submit()//适用于Callable接口
        service.shutdown();//关闭线程池

    }
}
三、解决线程安全问题

首先我们来看一段关于火车站卖票的问题

class Window1 extends Thread {
    private  int ticket = 100;
    Object obj = new Object();
            @Override
        public void run() {
                while (true) {
                    if (ticket > 0) {
                        try {
                            sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.println(getName() + ": 卖的票号为" + ticket);
                        ticket--;
                    } else {
                        break;
                    }
            }
        }

以卖票为例，卖票过程中出现重票和错票的情况 —>线程同步问题
出现问题的原因：当某个线程操作操作车票的过程中，尚未操作完成，其他线程参与进来，也操作车票
如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能改变。
在JAVA中，我们通过同步机制，来解决线程的安全问题

方式一：同步代码块

synchronized(同步监视器){
//需要被同步的代码
}
说明：

  1. 操作共享数据的代码，即为需要被同步的代码
  2. 共享数据：多个线程共同操作的变量，在卖票问题中，ticket即为共享数据。
  3. 同步监视器：俗称：锁。任何一个类的对象，都可以充当锁。
    要求：多个线程都必须要共用同一个锁。
//  方式一：
        @Override
        public void run() {
            synchronized (obj) {//当线程的创建的方式为实现，这里的obj 替换为this 表示调用这个方法的对象
                while (true) {
                    if (ticket > 0) {
                        try {
                            sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.println(getName() + ": 卖的票号为" + ticket);
                        ticket--;
                    } else {
                        break;
                    }
                }
            }
        }
方式二：同步方法
  //方式二：
@Override
public void run(){
        while (true){
            show();
        }
}
public synchronized void show(){//这里的同步监视器为默认的this
    if (ticket > 0) {
        try {
            sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(getName() + ": 卖的票号为" + ticket);
        ticket--;
    }
}

关于同步方法的总结：

  1. 同步方法仍然需要同步监视器，只是我们不需要显示声明
  2. 非静态的同步方法的同步监视器为：this
    静态的同步方法默认同步监视器为：当前这个类本身
  3. 同步的方式，解决了线程的安全问题。—好处
    操作同步代码时夏只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 —缺点
方式三：Lock锁

使用Lock 调用在需要同步的代码前调用lock方法，最终要调用unlock解锁

class Window3 implements Runnable{
    private int ticket = 100;
   private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
            while (true){
                try {
                lock.lock();
                if (ticket > 0){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName()+": 售出的票号为"+ ticket);
                    ticket--;
                }else {
                    break;
                }
            } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    lock.unlock();
                }
        }

    }
}
public class LockTest {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

提问：Lock锁和synchronized的异同
相同：都是用来解决线程同步问题
不同：synchronized执行完相应的同步代码后，会自动解锁
lock需要手动上锁和手动解锁

死锁问题：不同的线程分别占用对方的需要的同步资源不放手，都在等待对方放弃自己所需要的同步资源，就形成了死锁。

说明：
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
我们使用同步时，需要避免死锁。

举例：

public class DeadLockTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                  s2.append("1");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                synchronized (s2){
                    s1.append("b");
                    s2.append("2");
                }
                System.out.println(s1);
                System.out.println(s2);
            }
        }.start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
              }
                synchronized (s1){
                    s1.append("d");
                    s2.append("4");
                }
                System.out.println(s1);
                System.out.println(s2);
            }
        }).start();


        }
    }
四、线程的声明周期

图解：
在这里插入图片描述

五、线程的通信：
5.1、举例：两个线程交替打印100以内的数字
class Number implements Runnable {
    private int number = 1;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (number <= 100) {
                    notify();//注意：调用该方法的线程在这里唤醒了另一个线程
                    System.out.println(Thread.currentThread().getName() + ": 打印了" + number);
                    number++;
                    try {
                        wait();//这里使得调用run方法的线程进入阻塞状态
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    break;
                }
            }
        }
    }
}

public class ConcatenationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程一");
        t2.setName("线程二");

        t1.start();
        t2.start();
    }
}
5.2、wait()和notify()的说明
  • wait():一旦调用该方法，当前线程就进入阻塞状态，并释放同步监视器
  • notify()：一旦执行此方法，就会唤醒另一个在wait的线程。如果有多个线程，就唤醒优先级高的线程
  • notifyAll():唤醒所有wait的线程
  • 说明：wait()、notify()、notifyAll()必须写在同步代码块中。

一个面试题：wait()和sleep()的异同

相同：都能使线程进入阻塞状态
不同点：

  1. wait()是由Object类声明的，而sleep()是由Thread类声明的
  2. wait()会释放同步监视器，而sleep()不会释放同步监视器
  3. wait()只能声明在同步代码块或同步方法中，而sleep()可以在任何想使用的地方声明。
六、Thread类的常用方法
6.1、Thread类中常用方法的测试

测试Thread中的常用方法

  1. void start(): 启动线程，并执行对象的run()方法
  2. run(): 线程在被调度时执行的操作
  3. String getName(): 返回线程的名称
  4. void setName(String name):设置该线程名称
  5. static Thread currentThread(): 返当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
  6. currentThread():静态方法，返回执行当前代码的线程
  7. yield()：释放当前线程执行权
  8. join():在线程a中调用线程b的join，此时线程a进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞，继续执行
  9. sleep(long millistime)：在指定的millitime毫秒时间内，当前让当前线程“睡眠”指定的millitime毫秒。
  10. isAlive():判断当前线程是否还存活
public class ThreadTest2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i%20==0){
                yield();//释放当前CPU执行
            }
        }
    }
}


class TestMethod extends Thread {
    public static void main(String[] args) {
        ThreadTest2 test2 = new ThreadTest2();
        test2.setName("no.1");
        test2.start();
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 100; i++) {
            if (i % 2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i == 20){
                try {
                    test2.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
6.2、 线程的优先级：
  1. MAX_PRIORITY:10 -->最高优先级
    MIN_PRIORITY:1 --最低优先级
    NORM_PRIORITY:5
  2. 设置优先级：
    getPriority():获取线程的优先级
    setPriority():设置线程的优先级
    高优先级的线程会抢占低优先级的线程，但是只是从概率上讲，并不是说高优先级的线程会全部执行完，才去执行低优先级的线程
保持热爱&
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-学习多线程总结上
12-22
所以在进程之上的进一步划分就变得非常的重要，而且性能也会有所提高，所有的线程一定要依附进程才能够存在，那么进程一旦消失，线程也一定会消失，但反过来不一定，而Java是支持多线程的开发语言之一。 2. 多线程的...
java多线程学习
11-27
主要是结合课本和视频学习了一下java多线程的用法，这个专利适合于初学者学习多线程知识。
java多线程使用教程
鹏鹏2077
04-25 5305
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
编程必备：JAVA多线程详解
拾一二的博客
06-14 7807
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
多线程
跨越时空的记忆
03-21 206
进程与线程 进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空 间。（现在一个应用程序（软件）中通常也有多个进程，但也可以把进程近似看成软件）（进程之间互不影响） 线程是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程。 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。 每个线程都有自己的栈空间，共用一份堆内存。哪个线程调用的方法，此方法也会执行在此线程中。 线程调度 分时调度 所有线程轮流使用
超详细JAVA基础——多线程
热门推荐
qq_45781655的博客
04-12 2万+
学会Java多线程，只看一个博客就够了！
Java多线程——Java教案（十一）
zhang19903848257的博客
12-12 1026
文章目录多线程参考文章1. 多线程概述进程与线程的关系堆，方法取，共享栈多线程并发2. 创建线程继承Thread类实现Runable接口使用匿名内部类线程调用解析start()方法run()方法线程的生命周期3. 使用线程常用方法获取当前线程对象阻塞线程唤醒线程杀死线程方式一：使用stop（不推荐,已过时）方式二：使用return（推荐）线程调度线程优先级线程让位合并线程4. 线程的安全问题安全问题使用Sleep解决线程同步机制线程同步块线程同步方法Java中的变量共享问题不同情况下的加锁分析情况一：取钱，
Java多线程学习总结
09-14
Java多线程是编程中的重要概念，尤其在开发高并发、高性能的应用时不可或缺。本文将深入探讨Java中的线程和进程，以及如何在Java中实现多线程。 首先，理解线程和进程的概念至关重要。线程是操作系统分配CPU时间片...
java多线程学习视频
10-30
Java多线程是一块重要的内容，李兴华讲解的Java是一个很好的资源
java学习多线程处理
06-28
多线程开发的优势：改善用户体验，提高资源利用率（单线程的处理效率低下） 线程的使用步骤：定义一个线程，创建线程的实例，启动线程，终止线程 主线程：（java中所有的线程都是java.lang.Thread类或者其子类的一...
多线程技术教学视频
12-05
多线程技术教学视频
java多线程处理教学案例
01-07
一个简单的java多线程的开发案例。简单并易于理解，同时附加 生产者消费者模式
Java多线程学习
m0_64347807的博客
11-11 136
java多线程学习
Java多线程学习（吐血超详细总结）
常思考->有目标->重实践->善反思
10-31 486
http://blog.csdn.net/evankaka/article/details/44153709          林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka         目录(?)[-] 一扩展javalangThread类二实现javalangRunnable接口三Thread和Runna
Java多线程的知识点
weixin_59796310的博客
05-28 4862
Java多线程的知识点
java多线程入门（很到位）
weixin_45131680的博客
01-13 352
java中之所以有多线程机制，目的就是为了提高程序的处理效率。 对于单核的CPU来说，不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是多个事情同时在做。
Java多线程学习（详细）
weixin_34370347的博客
06-07 66
一、进程与线程的区别 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位） 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位） 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 　　 多进程是指操作系...
java多线程的学习
mmc_may的专栏
08-07 599
java多线程的实现的两种方法： 第一种方法：继承Thread类 package Thread; public class ThreadTest01 { public static void main(String[] args) { Thread01 th = new Thread01(); th.start(); // th.run();//属于方法的调
java多线程10：自定义线程池ThreadPoolExecutor
zhaofuqiangmycomm的博客
01-28 549
引言：在阿里新版619java开发手册有一段这样的话 1. 【强制】创建线程或线程池时请指定有意义的线程名称，方便出错时回溯。 2. 【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 说明：线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问 题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。 3. 【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这
java学习多线程的易错点
最新发布
12-01
Java学习多线程的易错点如下： 1.线程的启动必须使用start()方法，而不是run()方法，否则线程不会被启动。 2.多个线程访问共享资源时，可能会出现竞态条件（Race Condition），需要使用同步机制来避免。 3.使用wait...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值