Java多线程-基础

已于 2022-03-28 16:49:06 修改
阅读量120 收藏
点赞数
分类专栏： 多线程 文章标签： java 开发语言
于 2022-03-28 16:08:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44319442/article/details/123512359
版权

目录

1.上下文切换

2.实现多线程方式

3.Thread类的几个常用方法

4.Thread 和 Runnable 比较

5.Callable、Future、FutureTask

5.1 Callable

5.2 FutureTask

6.Java线程间的通信

6.1 锁与同步

6.2 等待/通知机制

 6.3 信号量 volatile

6.4 管道

6.5 其它通信相关

6.5.1 join 方法

6.5.2 sleep 方法

6.5.3 ThreadLocal 类

1.上下文切换

上下文切换指 cpu 从一个进程（或线程）切换到另一个进程（或线程）。上下文指某一时间点cpu 寄存器和程序计数器的内容。

上下文切换通常是计算密集型的，意味着此操作会消耗大量 cpu 时间，所以线程不是越多越好。

2.实现多线程方式

继承 Thread 类

public class Demo {
    public static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

    public static void main(String[] args) {
        Thread myThread = new MyThread();
        myThread.start();
    }
}

实现 Runnable 接口

public class Demo {
    public static class MyThread implements Runnable {
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

    public static void main(String[] args) {

        new Thread(new MyThread()).start();

        // Java 8 函数式编程，可以省略MyThread类
        new Thread(() -> {
            System.out.println("Java 8 匿名内部类");
        }).start();
    }
}

3.Thread类的几个常用方法

concurrentThread：返回当前正在执行的线程对象

start：开始执行线程，java虚拟机会调用 线程的 run 方法

yield：当前线程让出处理器的占用

sleep：当前线程睡眠一段时间

join：当前线程等待另一个线程执行完毕再继续执行。内部调用object 的 wait 方法实现的

4.Thread 和 Runnable 比较

单继承，多实现

Threa实现了 Runnable 接口

5.Callable、Future、FutureTask

5.1 Callable

与Runnable 接口类似，但是Callable接口是有返回值的，而且支持泛型。

Callable 接口一般配合线程池工具类 ExecutorService 来使用的：

// 自定义Callable
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        // 模拟计算需要一秒
        Thread.sleep(1000);
        return 2;
    }
    public static void main(String args[]) throws Exception {
        // 使用
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        // 注意调用get方法会阻塞当前线程，直到得到结果。
        // 所以实际编码中建议使用可以设置超时时间的重载get方法。
        System.out.println(result.get()); 
    }
}

5.2 FutureTask

FutureTask类有什么用？为什么要有这一个类？

Future只是一个接口，而它里面的 cancel，get，isDone等方法要自己实现起来都是非常复杂的。所以JDK提供了一个 FutureTask 类来供我们使用。

// 自定义Callable，与上面一样
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        // 模拟计算需要一秒
        Thread.sleep(1000);
        return 2;
    }
    public static void main(String args[]) throws Exception {
        // 使用
        ExecutorService executor = Executors.newCachedThreadPool();
        FutureTask<Integer> futureTask = new FutureTask<>(new Task());
        executor.submit(futureTask);
        System.out.println(futureTask.get());
    }
}

6.Java线程间的通信

6.1 锁与同步

Java中的锁是基于对象的，一般叫对象锁。线程同步可以解释为线程按照一定顺序执行。

public class ObjectLock {
    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread A " + i);
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread B " + i);
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(10);
        new Thread(new ThreadB()).start();
    }
}

这里申明了一个 lock 的对象锁，在两个线程中使用 synchronized 关键字加上了同一个对象锁。

6.2 等待/通知机制

基于 Object 类的 wait 方法和 notify 方法和 notifyAll 方法实现的。

notify 是随机唤醒一个线程，notifyAll 唤醒所有线程

 加入线程A获得了对象 obj 锁，执行同步代码块。在同步代码中调用 obj.wait 方法进入等待状态，这个时候锁被释放。

这个时候线程B获得对象 obj 锁，执行代码块，某一时刻调用 obj.notifyAll 唤醒其它线程，然后调用 wait 释放锁或者等线程执行完成再释放锁。

public class WaitAndNotify {
    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadA: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadB: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

需要注意的是等待/通知机制使用的是同一个对象锁，不同的对象锁不能用等待/通知机制。

 6.3 信号量 volatile

这里意思是使用 volatile 关键字修饰线程共享变量，让变量在线程间可见。

例：让两个线程交替执行

public class Signal {
    private static volatile int signal = 0;

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 0) {
                    System.out.println("threadA: " + signal);
                    signal++;
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 1) {
                    System.out.println("threadB: " + signal);
                    signal = signal + 1;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

volatile 变量需要进行原子操作，这里的 signal ++ 操作不是原子操作。根据需要使用 synchronized 给它上锁，或者使用 AutomaticInteger 等原子类。这一段代码不是线程安全的，进入while 循环语句后，当前线程可能CPU时间片使用玩进入等待时间，等重新获得 CPU时 signal 已经大于当前值了

6.4 管道

基于“管道流”的通信方式。JDK提供了 PipedWriter、PipedReader、PipedOutStream、PipedInputStream。前面两个基于字符流，后面两个基于字节流

public class Pipe {
    static class ReaderThread implements Runnable {
        private PipedReader reader;

        public ReaderThread(PipedReader reader) {
            this.reader = reader;
        }

        @Override
        public void run() {
            System.out.println("this is reader");
            int receive = 0;
            try {
                while ((receive = reader.read()) != -1) {
                    System.out.print((char)receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    static class WriterThread implements Runnable {

        private PipedWriter writer;

        public WriterThread(PipedWriter writer) {
            this.writer = writer;
        }

        @Override
        public void run() {
            System.out.println("this is writer");
            int receive = 0;
            try {
                writer.write("test");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        writer.connect(reader); // 这里注意一定要连接，才能通信

        new Thread(new ReaderThread(reader)).start();
        Thread.sleep(1000);
        new Thread(new WriterThread(writer)).start();
    }
}

6.5 其它通信相关

6.5.1 join 方法

join 方法是 Thread 的实例方法。让当前线程进入“等待”状态，等调用 join 方法的线程执行结束后，再执行当前线程。

public class Join {
    static class ThreadA implements Runnable {

        @Override
        public void run() {
            try {
                System.out.println("我是子线程，我先睡一秒");
                Thread.sleep(1000);
                System.out.println("我是子线程，我睡完了一秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadA());
        thread.start();
        thread.join();
        System.out.println("如果不加join方法，我会先被打出来，加了就不一样了");
    }
}

join 方法有两个重载方法，join（long ）、join（long，int）。底层都是调用 wait（long）方法。 

6.5.2 sleep 方法

sleep 方法是 Thread 类的一个静态方法。让当前线程随眠一段时间。

sleep 方法不会释放当前锁，wait 方法回释放锁

【wait】、【sleep】区别：

sleep 必须指定时间。

wait 释放CPU同时释放锁；sleep释放CPU但不释放锁，容易死锁。

wait 必须放在同步代码块中

6.5.3 ThreadLocal 类

ThreadLocal是一个本地线程副本变量工具类。内部是一个弱引用的Map来维护。

ThreadLocal类最常用的就是set方法和get方法。示例代码：

public class ThreadLocalDemo {
    static class ThreadA implements Runnable {
        private ThreadLocal<String> threadLocal;

        public ThreadA(ThreadLocal<String> threadLocal) {
            this.threadLocal = threadLocal;
        }

        @Override
        public void run() {
            threadLocal.set("A");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadA输出：" + threadLocal.get());
        }

        static class ThreadB implements Runnable {
            private ThreadLocal<String> threadLocal;

            public ThreadB(ThreadLocal<String> threadLocal) {
                this.threadLocal = threadLocal;
            }

            @Override
            public void run() {
                threadLocal.set("B");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ThreadB输出：" + threadLocal.get());
            }
        }

        public static void main(String[] args) {
            ThreadLocal<String> threadLocal = new ThreadLocal<>();
            new Thread(new ThreadA(threadLocal)).start();
            new Thread(new ThreadB(threadLocal)).start();
        }
    }
}

如果只是单纯的想要线程隔离，在每个线程中声明一个私有变量就好了呀，为什么要使用ThreadLocal？

如果开发者希望将类的某个静态变量（user ID或者transaction ID）与线程状态关联，则可以考虑使用ThreadLocal。

最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等。数据库连接和Session管理涉及多个复杂对象的初始化和关闭。如果在每个线程中声明一些私有变量来进行操作，那这个线程就变得不那么“轻量”了，需要频繁的创建和关闭连接。

我成长我快乐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程-同步访问 Java
qq_hua_xia的博客
11-08 1568
题目详情： 6-3 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有属性:private int balance方法: 相应的getter方法。 要求为该类编写：void deposit(int money)//存钱，在余额的基础上加上moneyvoid withdraw(int money)//取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会..
PTA：jmu-Java-07多线程-同步访问
m0_73680520的博客
12-18 542
已有现已有Account类，拥有相应的getter方法。//存钱，在余额的基础上加上money//取钱，在余额的基础上减去moneybalance
java多线程 线程交替执行（同步）的各种实现方案
最新发布
qq_43800449的博客
05-14 1121
如果想要指定执行顺序，则需要用信号量，或者自己实现一个标志位去模拟信号量如果不需要指定执行顺序，则谁先竞争到锁就谁先执行，执行完后唤醒另一个线程，再进入wait状态。
JAVA基础-多线程入门（详解）
0
07-28 891
线程（Thread)是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一个线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每个线程并行执行不同的任务。线程在Unix SystemV及SunOS中也被称为轻量进程（Lightweight Processes),但“轻量进程”更多指内核线程（Kernel Thread),而用户线程（User Thread)则被称为“线程”。
Java多线程基础知识
jiheng1的博客
06-06 134
Java多线程基础知识
Java基础--多线程详解
a18792721831的博客
06-06 2646
1.线程的概念； 2.线程如何使用； 3.jdk支持的基本线程池； 4.线程生命周期； 5.线程启动与终止； 6.后台线程； 7.线程继承其他类；
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
java 多线程-线程通信实例讲解
09-01
总的来说，Java的线程通信机制为多线程环境下的协作提供了基础。理解并正确使用`wait()`、`notify()`和`notifyAll()`，以及如何通过共享对象进行通信，是编写高效并发程序的关键。在实际编程中，应确保避免竞态条件...
Java多线程-Thread类的常用结构及线程优先级
01-27
Java多线程编程是开发高并发应用的基础，其中Thread类是实现多线程的核心类。本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称...
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
【Java多线程-创建多线程的基本方式一：继承Thread类】 在Java编程中，多线程是一种并发执行任务的机制，它允许多个任务在同一时间运行，从而提高程序的效率和响应速度。Java提供了多种创建多线程的方式，其中最...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
JAVA线程高级-线程按序交替执行
11-01
java多线程按需交替执行，java新特性。
【2023.6.4练习】jmu-Java-07多线程-Thread
FeAtherHZM的博客
06-04 310
复习通过继承Thread对象创建线程。
jmu-java-07多线程-同步访问_Python 多线程综述
weixin_31755877的博客
12-14 399
多线程是一个不局限于语言的概念。多线程解决的问题是在更好的利用系统资源的情况下，比如内存、文件系统、网络等，充分利用 CPU 的空闲时间片。同一个进程的所有线程是共享同一内存的，所以不需要特殊的数据传输机制，这样不同任务之间的协调操作与运行、数据的交互、资源的分配等问题更加易于解决。涉及到多线程就需要协调他们进行线程同步，来实现线程安全。实现线程同步用到 5 种方式：分别是 Lock, RLock...
jmu-java-07多线程-同步访问_Java并发编程(03)：多线程并发访问，同步控制
weixin_28693683的博客
12-07 1083
一、并发问题多线程学习的时候，要面对的第一个复杂问题就是，并发模式下变量的访问，如果不理清楚内在流程和原因，经常会出现这样一个问题：线程处理后的变量值不是自己想要的，可能还会一脸懵的说：这不合逻辑吧？1、成员变量访问多个线程访问类的成员变量，可能会带来各种问题。public class AccessVar01 { public static void main(String[] args)...
Java多线程的知识点
weixin_59796310的博客
05-28 4865
Java多线程的知识点
jmu-Java-07多线程-互斥访问 (5分)
嗯呢嗯呢的博客
06-06 2163
6-8jmu-Java-07多线程-互斥访问(5分) 定义Account类属性：private int balance方法： getter方法void deposit(int money)//存钱，在余额的基础上加上moneyvoid withdraw(int money)//取钱，在余额的基础上减去money 注意：可能有多个线程通过deposit或withdraw方法同时存取Account对象的balance属性。 裁判测试程序： import java.util.Scanner; ...
java 多线程 递增_Java的多线程编程模型5--从AtomicInteger开始(自增长实现)
weixin_31517893的博客
02-16 364
AtomicInteger，一个提供原子操作的Integer的类。在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。来看AtomicInteger提供的接口。//获取当前的值public final int get()//取当前的值，并设置新的值public final ...
Java多线程学习（吐血超详细总结）
热门推荐
Gabriel的专栏
06-15 7万+
转自：http://www.mamicode.com/info-detail-517008.html 目录(?)[-] 一扩展javalangThread类二实现javalangRunnable接口三Thread和Runnable的区别四线程状态转换五线程调度六常用函数说明 使用方式为什么要用join方法 七常见线程名词解释八线程同步九线程数据传递      本文主要
Java第九章多线程程序设计基础篇.ppt
11-13
"Java第九章多线程程序设计基础" 在Java编程中，多线程是实现并发执行的关键技术，允许程序同时执行多个任务。本章节主要涵盖了多线程程序设计的基础概念，创建方法，线程状态与控制，优先级与调度，同步机制以及...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值