一篇看懂Java多线程

已于 2022-10-23 09:50:13 修改
阅读量633 收藏
点赞数 1
分类专栏： java 文章标签： java 开发语言
于 2022-04-01 14:27:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zrulin/article/details/123897013
版权

java线程安全

文章目录

一个概念：线程的同步（主要解决线程的安全问题）

问题：

  1. 多个线程执行的不确定性引起执行结果的不稳定
  2. 多个线程对一个内容的共享，会造成操作的不完整性，会破坏数据。

在Java中，通过同步机制来解决线程安全问题。

最初的两种方式：

方式一：同步代码块

synchronized(同步监视器){

//需要同步的代码

}
//说明：操作共享数据的代码，即为需要被同步的代码。
//共享数据：多个线程共同操作的变量。
//同步监视器：俗称：锁。任何一个类的对象都可以充当锁。要求：多个线程必须共用同一把锁。

示例代码：

同步代码块处理实现Runnable接口的线程安全问题：

public class SynchronizedTest {
    public static void main(String[] args) {
        RunnableTest runnableTest = new RunnableTest();
        Thread thread = new Thread(runnableTest);
        Thread thread1 = new Thread(runnableTest);
        Thread thread2 = new Thread(runnableTest);
        thread.start();
        thread1.start();
        thread2.start();
    }

}

class RunnableTest implements Runnable{
    private static int target = 100;

    @Override
    public void run() {
        while (true){
            synchronized(this){//在实现Runnable接口创建多线程的方式中，可以 考虑 使用this充当同步监视器。
                if(target > 0){
                    System.out.println("线程："+Thread.currentThread().getName()+"拿到的数字是："+target);
                    target--;
                }else {
                    break;
                }
            }
        }
    }
}

同步代码块处理继承Thread类的线程安全问题：

public class ThreadTest {
    public static void main(String[] args) {
        ThreadClassTest test = new ThreadClassTest();
        ThreadClassTest test1 = new ThreadClassTest();
        ThreadClassTest test2 = new ThreadClassTest();

        test.start();
        test1.start();
        test2.start();
    }
}

class ThreadClassTest extends Thread{

    private static int target = 100;

    @Override
    public void run() {
        while (true){
            synchronized(ThreadClassTest.class){
                if(target > 0){
                    System.out.println("线程："+Thread.currentThread().getName()+"拿到的数字是："+target);
                    target--;
                }else {
                    break;
                }
            }
        }
    }
}

优点：解决了线程的安全问题

缺点：操作同步代码时只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。

这就是鱼与熊掌不可兼得吧。

方式二：同步方法

  • 如果操作的共享数据完整的声明在一个方法中，就可以将此方法声明为同步的。

示例代码：

同步方法处理实现Runnable接口的线程安全问题：

public class SynchronizedTest1 {
    public static void main(String[] args) {
        RunnableTest1 runnableTest = new RunnableTest1();
        Thread thread = new Thread(runnableTest);
        Thread thread1 = new Thread(runnableTest);
        Thread thread2 = new Thread(runnableTest);
        thread.start();
        thread1.start();
        thread2.start();
    }

}

class RunnableTest1 implements Runnable{
    private int target = 100;

    @Override
    public void run() {
        while (true){
            show();
        }
    }
    public synchronized void show(){// 默认使用的同步监视器是this
        if(target > 0){
            System.out.println("线程："+Thread.currentThread().getName()+"拿到的数字是："+target);
            target--;
        }
    }
}

同步方法处理继承Thread类的线程安全问题：

public class ThreadTest1 {
    public static void main(String[] args) {
        ThreadClassTest1 test = new ThreadClassTest1();
        ThreadClassTest1 test1 = new ThreadClassTest1();
        ThreadClassTest1 test2 = new ThreadClassTest1();

        test.start();
        test1.start();
        test2.start();
    }
}

class ThreadClassTest1 extends Thread{

    private static int target = 100;

    @Override
    public void run() {
        while (true){
            show();
        }
    }
//    public synchronized void show(){// 默认使用的同步监视器时this,有t1,t2，t3三个对象，所以错误
    private static synchronized void show(){//同步监视器就是 ThreadClassTest1.class
        if(target > 0){
            System.out.println("线程："+Thread.currentThread().getName()+"拿到的数字是："+target);
            target--;
        }
    }
}

同步方法仍然涉及到同步监视器，只是不需要我们显示的声明。

非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身(类.class)

线程安全之单例模式-懒汉式

同步方法的方式：

class User{

    private User(){}

    private static User user;

    public static synchronized User getUser(){
        if(user == null){
            if(user == null){
                user = new User();
            }
        }
        return user;
    }
}

使用这种方式不太好，因为不管user是不是以及实例化过，在这里全部单线程执行。

同步代码块的方式：

class User{

    private User(){}

    private static User user;

    public static User getUser(){
        if(user == null){
            synchronized (User.class){
                if(user == null){
                    user = new User();
                }
            }
        }
        return user;
    }
}

这里用同步代码块更好，因为如果已经有实例对象了，就可以多线程执行了，全部拿到的同一个对象，不会一股脑阻塞在这里。效率更高

线程的死锁问题

用一段代码演示死锁问题：

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

    new Thread(){
        @Override
        public void run() {
            synchronized(s1){
                s1.append("a");
                s2.append("1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(s2){
                    s1.append("b");
                    s2.append("2");

                    System.out.println(s1.toString());
                    System.out.println(s2.toString());
                }
            }
        }
    }.start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized(s2){
                s1.append("c");
                s2.append("3");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(s1){
                    s1.append("d");
                    s2.append("4");

                    System.out.println(s1.toString());
                    System.out.println(s2.toString());
                }
            }
        }
    }).start();
}

在这个代码中第一个线程首先握住s1的锁，然后需要s2的锁才能执行下去，如果这个时候第二个线程握住了s2这个锁，同时需要s1的锁才能往下执行，两个线程所需要的锁都在对方手里，这样就形成了死锁。

官方一点的解释：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

我们使用同步时要避免死锁

避免死锁：

  1. 考虑专门的算法，避开这样的问题
  2. 尽量减少使用同步资源
  3. 尽量避免嵌套同步

方式三：Lock（锁）

jdk1.5提供的一个新特性。

Lock是一个接口，我们使用它的一个典型的实现类:ReentranLock类

示例代码：

Lock（锁）处理实现Runnable接口的线程安全问题：

public class LookTest {

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        Thread thread1 = new Thread(lockTest);
        Thread thread2 = new Thread(lockTest);
        Thread thread3 = new Thread(lockTest);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class LockTest implements Runnable{
    private int target = 100;

    /**
     *  private ReentrantLock lock = new ReentrantLock(true);
     *  true表示公平，就是线程轮流执行，不会有那种插队的现象
     *  无参构造器默认就是参数时false
     *   private ReentrantLock lock = new ReentrantLock();
     *
     */
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){

            try{
                //调用锁定方法lock()
                lock.lock();
                if(target > 0){
                    System.out.println("线程："+Thread.currentThread().getName()+"拿到的数字是："+target);
                    target--;
                }else {
                    break;
                }
            }finally {
                //调用解锁方法unlock()
                lock.unlock();
            }


        }
    }
}

synchronized和lock的异同

同：都可以解决线程安全问题

异：synchronized在执行完相应的同步代码块之后，自动的释放同步监视器，lock需要手动的去启动同步，同时手动结束同步。明显的lock更加的灵活

sleep() 和 wait()的异同

  • 相同点
    • 一旦执行方法，都可以使得当前线程进入阻塞状态
  • 不同点
    • 两个方法执行的位置不同，Thread类中声明sleep()，Object类中声明wait()
    • 调用的要求不同，sleep（）可以在任何需要的场景下调用，wait（）只能使用在同步代码块或同步方法中。
    • 如果两个方法都使用在同步代码块或者同步方法中，sleep()不会释放同步监视器（锁），wait（）会释放锁。

新增线程创建方式

实现callable接口

jdk5.0新增的。

与Runable相比，Callable更强大些

  • 相比run方法，可以有返回值
  • 方法可以抛出异常
  • 支持泛型的返回值
  • 需要借助FutureTask，比如获取返回结果

Future接口：

  • 可以对具体的Runable，callable任务的执行结果进行取消，查询是否完成，获取结果等。
  • FutureTask是接口Future的唯一实现类
  • FutureTask同时实现了Runnable，Future接口，它既可以作为Runnable被线程执行，又可以作为Future得到Callable的值。

示例代码：

public class CallableTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类对象
        NumTread numTread = new NumTread();

        //4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象
        FutureTask<Integer> futureTask = new FutureTask<>(numTread);

        //5.将FutureTask对象作为参数传递到Thread构造器中，创建Thread对象，并调用start()启动线程。
        new Thread(futureTask).start();

        try {
            //6，获取Callable中call()方法的返回值(看需求)
            //get（）的返回值即为FutureTask构造器参数Callable实现类重写call()的返回值
            Integer sum =  futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.创建一个callable的实现类，
class NumTread implements Callable<Integer>{

    //2.实现call方法，将此线程需要执行的操作声明在call中
    @Override
    public Integer call() throws Exception {
        int sum = 0 ;
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

使用线程池

背景：

​ 经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响非常大。

解决办法：

​ 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放入池中。可以避免频繁创建销毁，实现重复利用。

好处：

  • 提高响应速度（减少创建新新线程的时间）
  • 降低资源消耗。（重复利用线程池中的线程，不需要每次都创建）
  • 便于线程管理
    • 线程池大小
    • 最大线程数
    • 线程没有任务时最多保持多长时间终止。
    • …

jdk1.5起提供了线程池相关的API：ExecutorService 和 Executors

  • ExecutorService：真正的线程池接口，常见子类ThreadPoorExecutor
    • void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
    • <T> Future<T> submit(Callable<T> task) ：执行任务，有返回值，一般用来执行Callable
    • void shutdown()：关闭连接池
  • Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池
    • Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
    • Executors.newFixedThreadPool(n);创建一个可重用固定线程数的线程池
    • Executors.newSingleThreadExecutor() :创建一个只有一个线程的线程池
    • Executors.newScheduledThreadPool(n):创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

示例代码：

public class ThreadPoolTest {

    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //设置连接池的属性
        //强转为ExecutorService接口的实现类
//        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//        service1.setCorePoolSize(15);
//        service1.setMaximumPoolSize();

        //执行指定线程的操作。需要实现Runnable接口或Callable接口实现类的对象
        service.execute(new ThreadPoolGetNumber());//一般用来执行Runnable
        service.execute(new ThreadPoolGetNumber());//一般用来执行Runnable
        service.execute(new ThreadPoolGetNumber());//一般用来执行Runnable

//        service.submit();//一般用来执行Callable
        //关闭连接池
        service.shutdown();
    }

}

class ThreadPoolGetNumber implements Runnable{
    private static Integer target = 100;

    @Override
    public void run() {
        while (true){
            synchronized(ThreadPoolGetNumber.class){
                if(target > 0){
                    System.out.println("线程："+Thread.currentThread().getName()+"拿到的数字是："+target);
                    target--;
                }else {
                    break;
                }
            }
        }
    }
}

以上内容大部分是看康师傅视频时的笔记，详情请看：
尚硅谷康师傅，你值得拥有

小黑cc
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
一篇文章弄懂Java多线程基础和Java内存模型
12-21
文章目录一、多线程的生命周期及五种基本状态二、Java多线程的创建及启动1.继承Thread类，重写该类的run()方法2.通过实现Runnable接口创建线程类3.通过Callable和Future接口创建线程三、Java内存模型概念四、内存间的交互操作五、volatile和synchronized的区别 写在前面：提起多线程大部门同学可能都会皱起眉头不知道多线程到底是什么、什么时候可以用到、用的时候是不是有共享变量问题等等一大堆问题。本篇文章将分为两部分第一部分是讲解多线程基础、第二部分讲解Java内存模型。 一、多线程的生命周期及五种基本状态 Java多线程生命周期，首先看下面这张经典
谈谈 Callable 任务是怎么运行的？它的执行结果又是怎么获取的?
weixin_38171245的博客
09-06 347
谈谈 Callable 任务是怎么运行的？它的执行结果又是怎么获取的？ 向线程池提交Callable任务，会创建一个新线程(执行任务的线程)去执行这个Callable任务，但是通过Future#get获取任务的执行结果是在提交任务的调用者线程中，那问题一：调用者线程如何获取执行任务的线程的结果？ 在JDK中，有2种类型的任务，Runnable和Callable，但是具体到线程池执行任务的...
java并发编程第十课 Callable、Runnable、Future
fegus的博客
05-26 712
第48讲：Callable 和 Runnable 的不同？ 你好，欢迎来到第 48 课时，在本课时我们将讲解 Callable 和 Runnable 的不同。 为什么需要 Callable？Runnable 的缺陷 先来看一下，为什么需要 Callable？要想回答这个问题，我们先来看看现有的 Runnable 有哪些缺陷？ 不能返回一个返回值 第一个缺陷，对于 Runnable 而言，它不能返回一个返回值，虽然可以利用其他的一些办法，比如在 Runnable 方法中写入日志文件或者修改某个共享的对象的办法
关于线程的一些知识
qq_40876806的博客
11-25 204
一 线程和进程的区别 二 创建线程的方式 2.1 继承Thread类,重写run() 2.2 实现Runnable接口,重写run() 1)多个线程同时操作同一个资源,就有可能会出现数据不安全的问题 2)可以通过共享的标识来控制多线程的执行中线程结束 3)被重写方法上的异常抛出类型要求大于等于重写方法的异常 2.3 实现juc包下Callable接口,重写call() 2.3.1 创建与开启 使用线程池实现 2.3.2 优点 1)call中可以抛出...
Java多线程-实现Callable接口的call()方法，示例
DataB的博客
07-06 5844
创建步骤，首先实现Callable接口的call()方法并指定返回值；然后创建实现类实例；FutureTask类使用Callable实现类的实例通过FutureTask的单参数构造器创建FutureTask的实例；通过Thread类的构造器创建Thread类实例，并执行start方法，启动线程；最后通过FutureTask实例的get()方法阻塞拿到Callable实现类的call方法的返回值。 示例如下， public class CallableTest implements Ca...
转载：深入学习java源码之Callable.call()与Future.get()
黄道婆的专栏
07-08 555
原始链接：https://blog.csdn.net/qq_35029061/article/details/86750369 深入学习java源码之Callable.call()与Future.get() wespten 2019-02-03 08:07:50 7904 收藏 8 分类专栏： Java源码 文章标签： 深入学习java源码之Callable.call()与Fut 版权 深入学习java源码之Callable.call()与Future.get() Callable和Futur..
Callable接口中的call方法及返回对象Future 和CountDownLatch计数器的使用
taiguolaotu的博客
08-03 1594
jdk1.5中的实现Callable接口中实现call方法创建线程与之前Thread类中或Runnable接口中的重写/实现run方法的不同 首选call方法最大不同就是增加了抛出异常及其返回值的功能。 Callable接口与Future, 多线程并发情况下利用Future对象接收返回值，上代码。 import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concur
实现Callable接口，什么时候调用call()方法
huangchunxia_1的博客
08-15 1万+
最近，项目中经常接触线程，特别是在推送MQ的时候，都是使用线程来执行操作。在这里，用一个简单的例子来整理一个很简单的使用方法。代码如下： public class TestThread {     public static void main(String[] args) {         //使用main方法模拟Callable的call()方法的调用         CallableTe...
Callable异步原理简析
热门推荐
轻风无言的博客
03-27 2万+
异步执行，应该不会陌生，那么在java中是怎么用的呢？又是如何实现的？下面我们循序渐进，慢慢分析。
Java的六大问题你都懂了吗
12-13
从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中，s原先指向一个String对象，内容是"Hello",然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，...
java面试题以及技巧
11-25
│ 164个完整Java代码.zip │ J2EE综合－－Struts常见错误的全面汇总.txt │ java程序员面试资料.zip │ JAVA笔试题（上海释锐）.pdf │ MIME简介.txt │ SCJP试题详解.pdf │ SQL面试题_心灵深处.htm │ Struts+...
java面试题目与技巧1
11-25
│ 164个完整Java代码.zip │ J2EE综合－－Struts常见错误的全面汇总.txt │ java程序员面试资料.zip │ JAVA笔试题（上海释锐）.pdf │ MIME简介.txt │ SCJP试题详解.pdf │ SQL面试题_心灵深处.htm │ Struts+...
Java多线程相关知识
qq_45970867的博客
09-03 464
具有较高优先级的线程优先于优先级较低的线程执行。当在一些线程中运行的代码创建一个新的 Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程。当线程被创建并启动后，它既不是一启动就进入了执行状态，也不是一直处于执行状态，在线程的生命周期中，它要经过新建（New）、就绪（Ready）、运行（Running）、阻塞（Blocked）、和死亡（Dead）5种状。默认值为5，如果设置了线程的优先级，不能保证该线程一定先执行，只能提高该线程优先执行的可能性。
java多线程之Callable
翻过一座座山
08-12 1251
Callable和Runnbale一样代表着是线程任务，区别在于Callable有返回值并且可以抛出异常。 创建并启动有返回值的线程的步骤如下： 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且该call()方法有返回值。 将Callable实例传入FutureTask类。 使用FutureTask对象作为Thread对象的target创建...
Callable获取返回值
sinat_24296421的博客
12-25 7347
最近在写一个统计任务，恩，也不算最近了，过去一个多月了都。 任务要求，每周日凌晨之前统计用户总数及增长量，因为是分库分表的，统计维度要求到库级别和表级别。 大致实现思路，滚动时，每个表开一个线程做COUNT操作，因为要统计库级别的数据，所以需要等到所有线程结束后拿到所有线程的返回值，进行累加。（至于这里为什么滚动表的时候都要开一个线程，其实不开线程也OK的，但是，这种线程获取返回值的还没有用过...
创建线程的三种方式
weixin_40215624的博客
05-30 154
1、继承Thread类 2、实现Runnable接口 3、使用Callable和Future创建线程 Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大，call()方法可以有返回值，而且可以声明抛出异常 步骤如下： 1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表...
深入学习java源码之Callable.call()与Future.get()
悦分享
02-03 1万+
深入学习java源码之Callable.call()与Future.get() Callable和Future出现的原因 创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。  这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。  如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。 而自从Java ...
日常Java练习题（每天进步一点点系列）
『愚』的博客
07-16 1万+
提示：好多小伙伴反映，直接看到答案不太好，那我把答案的颜色设置为透明，答案位置还是在题目后面，需要鼠标选中才能看见（操作如下图），同时为了手机端的小伙伴（手机端也可以长按选中查看），我还会把所有答案放到文章最下面，希望给每天进步一点点的小伙伴更好的体验。 前段时间实在是有点忙，抱歉，抱歉，抱歉！！！ 1、以下二维数组声明合法的是（ ） 正确答案: C 你的答案: C (正确) char[2][3] ch = new char[][] char[2][] ch = new char[][3] char[
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 261
借助jdeps分析出jar包的增量文件
说一说java多线程的知识
05-16
Java多线程是指在一个Java程序中同时运行多个线程，每个线程都有自己的执行路径，独立地运行。Java多线程可以提高程序的效率，使得程序能够同时处理多个任务。以下是一些Java多线程的基本知识： 1. 线程的创建：Java中创建线程的方法有两种，一种是继承Thread类，重写该类的run()方法；另一种是实现Runnable接口，重写该接口中的run()方法。 2. 线程的状态：Java中的线程有五种状态，分别是新建状态、就绪状态、运行状态、阻塞状态和死亡状态。一个线程可以在这些状态之间切换。 3. 线程的同步：Java中的线程同步是指多个线程在访问共享资源时，能够按照一定的顺序依次访问，避免数据的不一致性。Java中提供了synchronized关键字、Lock和Condition等机制来实现线程同步。 4. 线程的通信：Java中的线程通信是指多个线程之间进行协作，以完成某个任务。Java中提供了wait()、notify()和notifyAll()等方法来实现线程之间的通信。 5. 线程池：Java中的线程池是一种管理线程的机制，它可以实现线程的复用，减少线程的创建和销毁的开销，提高程序的效率。 以上是Java多线程的一些基本知识，深入了解这些知识可以让开发者更好地利用多线程来提高程序的效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小黑cc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值