一篇看懂Java多线程

已于 2022-10-23 09:50:13 修改
阅读量694 收藏
点赞数 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;
                }
            }
        }
    }
}

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

java语言程序设计基础篇+进阶篇源码
01-07
- **多线程**：Java提供了Thread类和Runnable接口来实现并发编程，理解线程的创建、同步和通信对于处理多任务至关重要。 - **反射机制**：反射允许程序在运行时动态访问类的信息，创建和操作对象，是Java强大的...
Java多线程-实现Callable接口的call()方法，示例
DataB的博客
07-06 6252
创建步骤，首先实现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 653
原始链接：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 1719
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-20
学习这些示例代码时，你不仅要看懂每一行代码，还要尝试理解背后的逻辑和设计决策。动手实践是提升编程技能的关键，你可以运行这些程序，调试错误，甚至修改代码以满足自己的需求。这样，你将逐步建立起解决实际问题...
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面试题及技巧4
11-25
│ 164个完整Java代码.zip │ J2EE综合－－Struts常见错误的全面汇总.txt │ java程序员面试资料.zip │ JAVA笔试题（上海释锐）.pdf │ MIME简介.txt │ SCJP试题详解.pdf │ SQL面试题_心灵深处.htm │ Struts+...
java多线程之Callable
翻过一座座山
08-12 1296
Callable和Runnbale一样代表着是线程任务，区别在于Callable有返回值并且可以抛出异常。 创建并启动有返回值的线程的步骤如下： 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且该call()方法有返回值。 将Callable实例传入FutureTask类。 使用FutureTask对象作为Thread对象的target创建...
Callable获取返回值
sinat_24296421的博客
12-25 7517
最近在写一个统计任务，恩，也不算最近了，过去一个多月了都。 任务要求，每周日凌晨之前统计用户总数及增长量，因为是分库分表的，统计维度要求到库级别和表级别。 大致实现思路，滚动时，每个表开一个线程做COUNT操作，因为要统计库级别的数据，所以需要等到所有线程结束后拿到所有线程的返回值，进行累加。（至于这里为什么滚动表的时候都要开一个线程，其实不开线程也OK的，但是，这种线程获取返回值的还没有用过...
Java线程（线程池、创建线程的第三种方法callable)续上一章
m0_57532232的博客
03-15 241
线程池 补充资料：Doug Lea (JCP组织的一人)对线程池部分贡献巨大 常用线程池的接口和类： Executor:线程池的顶级接口 ExecutorService:线程池接口可用submit（Runnable Task）提交任务代码。包含：Shutdown； Shutdownnow等 Executors工厂类:可以通过这一个方法得到一个线程池 NewFixedThreadPool(int n Thread):获取固定数量的线程池。参数：指线程池中线程的数量 NewCacheThre
深入学习java源码之Callable.call()与Future.get()
悦分享
02-03 1万+
深入学习java源码之Callable.call()与Future.get() Callable和Future出现的原因 创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。  这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。  如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。 而自从Java ...
创建多线程的方式三：实现Callable接口
m0_55895641的博客
01-11 910
实现Callable接口与实现Runnable接口方法差不多，不同之处在于实现Callable接口是重写Call方法，且Call方法是有返回值的。Call方法也可以抛出异常，也支持泛型。 步骤：1.创建实现Callable接口的实现类 2.重现实现类中的Call()方法 3.创建实现类的对象 4.将实现类对象作为参数传入FutureTask构造器中，创建FutureTask对象 5.将FutureTask创建的对象作为参数传入Thread类构造器中创建Thread对象并调用start()方法。
日常Java练习题（每天进步一点点系列）
『愚』的博客
07-16 1万+
提示：好多小伙伴反映，直接看到答案不太好，那我把答案的颜色设置为透明，答案位置还是在题目后面，需要鼠标选中才能看见（操作如下图），同时为了手机端的小伙伴（手机端也可以长按选中查看），我还会把所有答案放到文章最下面，希望给每天进步一点点的小伙伴更好的体验。 前段时间实在是有点忙，抱歉，抱歉，抱歉！！！ 1、以下二维数组声明合法的是（ ） 正确答案: C 你的答案: C (正确) char[2][3] ch = new char[][] char[2][] ch = new char[][3] char[
创建线程的三种方式
weixin_40215624的博客
05-30 184
1、继承Thread类 2、实现Runnable接口 3、使用Callable和Future创建线程 Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大，call()方法可以有返回值，而且可以声明抛出异常 步骤如下： 1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表...
并发基础之Callable与Future获取异步执行结果
最新发布
勤于笔记，成于点滴。
03-20 894
在多线程编码需要获取线程异步执行结果的情况下，我们推荐使用实现Futrue 接口的方式，它比Callable方式多了很多的操作执行线程的方法，比如 cancel() 取消执行、isCancelled () 获取是否取消状态、isDone() 任务是否完成等等。在实际的开发中，我们也推荐使用多线程来创建Futrue获取执行结果。
Callable的使用和自定义自己的Callable接口
chenjianhuideyueding的博客
07-12 590
Callable对比Runnale接口来说，可以返回线程执行的结果： public static void main(String[] args) throws Exception { FutureTask future = new FutureTask(() -> { TimeUnit.SECONDS.sleep(10); return "hello"; }); new Thread(future
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小黑cc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值