Java线程学习

已于 2022-05-07 08:33:12 修改
阅读量173 收藏
点赞数
分类专栏： Java巩固回炉 文章标签： java
于 2022-04-24 22:32:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39657458/article/details/124392471
版权

文章目录

前言

随着项目系统的繁杂程度增大，项目需要响应速度、执行速度、满足高并发，除了使用负载、缓存、消息等技术，但其实在Java代码时使用多线程从编码上就加快了流程执行速度。

一、多线程是什么？

在计算机中，我们把一个任务称为一个进程，那么进程内部也存在多个任务，那么我们把子任务称之为线程。

通俗易懂点：有三份工作需要处理，一个人处理三份工作需要3h，如果3个人同时处理三份工作只需花费1h，这就是多线程。

二、创建线程

1.方法一（继承Thread，重写run()方法）

public class Main {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start(); // 启动新线程
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("start test thread!");
    }
}

2.方法二（Runnable接口实现）

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("start test thread!");
    }
}

3.方法三（Java8及以上可使用简写）

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("start test thread!");
        });
        t.start(); // 启动新线程
    }
}

以上写法有可能会混淆各位同学们，你这写法和运行main方法有什么不同，那么通过以下实例为各位进行讲解。

public class Main {
    public static void main(String[] args) {
        System.out.println("主方法运行");
        Thread t = new Thread() {
            public void run() {
                System.out.println("线程开始");
                System.out.println("线程结束");
            }
        };
        t.start();
        System.out.println("主方法结束");
    }
}

运行结果是: 

 通过以上示例可知，线程是不影响主方法，可以同时开始。

三、线程的状态有哪些？ 

1.状态清单

  • 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  • 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
  • 阻塞(BLOCKED)：表示线程阻塞于锁。
  • 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
  • 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
  • 终止(TERMINATED)：表示该线程已经执行完毕。

2.线程状态图

四、中断线程

中短线程使用interrupt()方法，目标线程需要反复检测自身状态是否是interrupted状态，如果是，就立刻结束运行。

1、调用interrupt()示例代码：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        Thread.sleep(1); // 暂停1毫秒
        t.interrupt(); // 中断t线程
        t.join(); // 等待t线程结束
        System.out.println("end");
    }
}

class MyThread extends Thread {
    public void run() {
        int n = 0;
        while (! isInterrupted()) {
            n ++;
            System.out.println(n + " hello!");
        }
    }
}

运行结果是：

2、标志位示例代码

public class Main {
    public static void main(String[] args)  throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        Thread.sleep(1);
        t.running = false; // 标志位置为false
    }
}

class MyThread extends Thread {
    public volatile boolean running = true;
    public void run() {
        int n = 0;
        while (running) {
            n ++;
            System.out.println(n + " hello!");
        }
        System.out.println("end!");
    }
}

 运行结果：

 五、守护线程

守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。

1、调用setDaemon(true)把该线程标记为守护线程

Thread t = new MyThread();
t.setDaemon(true);
t.start();

备 ：护线程不能持有任何需要关闭的资源，例如打开文件等，因为虚拟机退出时，守护线程没有任何机会来关闭文件，这会导致数据丢失。

 六、线程同步

synchronized方法保证了代码块在任意时刻最多只有一个线程能执行

public class Main {
    public static void main(String[] args) throws Exception {
        var add = new AddThread();
        var dec = new DecThread();
        add.start();
        dec.start();
        add.join();
        dec.join();
        System.out.println(Counter.count);
    }
}

class Counter {
    public static final Object lock = new Object();
    public static int count = 0;
}

class AddThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
                Counter.count += 1;
            }
        }
    }
}

class DecThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
                Counter.count -= 1;
            }
        }
    }
}

运行结果： 

那么很多小伙伴好奇为什么要使用 synchronized，那我们用不加锁的运行一下

运行结果：

 每次运行结果都不一致，是因为两个线程共用一个变量没有通过synchronized进行限制。

七、死锁

一个线程可以获取一个锁后，再继续获取另一个锁

public void add(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value += m;
        synchronized(lockB) { // 获得lockB的锁
            this.another += m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

public void dec(int m) {
    synchronized(lockB) { // 获得lockB的锁
        this.another -= m;
        synchronized(lockA) { // 获得lockA的锁
            this.value -= m;
        } // 释放lockA的锁
    } // 释放lockB的锁
}

在获取多个锁的时候，不同线程获取多个不同对象的锁可能导致死锁。对于上述代码，线程1和线程2如果分别执行add()和dec()方法时：

  • 线程1：进入add()，获得lockA；
  • 线程2：进入dec()，获得lockB。

随后：

  • 线程1：准备获得lockB，失败，等待中；
  • 线程2：准备获得lockA，失败，等待中。

此时，两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

那我们应该如何避免死锁？

线程获取锁的顺序要一致。即严格按照先获取lockA，再获取lockB的顺序，改写dec()方法如下：

public void add(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value += m;
        synchronized(lockB) { // 获得lockB的锁
            this.another += m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

public void dec(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value -= m;
        synchronized(lockB) { // 获得lockB的锁
            this.another -= m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

 八、wait和notify

多线程协调运行的原则就是：当条件不满足时，线程进入等待状态；当条件满足时，线程被唤醒，继续执行任务。

wait():线程进入等待状态

notify():唤醒一个正在等待的线程

示例代码：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        var q = new TaskQueue();
        var ts = new ArrayList<Thread>();
        for (int i=0; i<5; i++) {
            var t = new Thread() {
                public void run() {
                    // 执行task:
                    while (true) {
                        try {
                            String s = q.getTask();
                            System.out.println("execute task: " + s);
                        } catch (InterruptedException e) {
                            return;
                        }
                    }
                }
            };
            t.start();
            ts.add(t);
        }
        var add = new Thread(() -> {
            for (int i=0; i<10; i++) {
                // 放入task:
                String s = "t-" + Math.random();
                System.out.println("add task: " + s);
                q.addTask(s);
                try { Thread.sleep(100); } catch(InterruptedException e) {}
            }
        });
        add.start();
        add.join();
        Thread.sleep(100);
        for (var t : ts) {
            t.interrupt();
        }
    }
}

class TaskQueue {
    Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s) {
        this.queue.add(s);
        this.notifyAll();
    }

    public synchronized String getTask() throws InterruptedException {
        while (queue.isEmpty()) {
            this.wait();
        }
        return queue.remove();
    }
}

九、ReentrantLock 

从Java 5开始，引入了一个高级的处理并发的java.util.concurrent包，它提供了大量更高级的并发功能，能大大简化多线程程序的编写。

我们将传统的synchronized改写一下

public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count;

    public void add(int n) {
        lock.lock(); //获取锁
        try {
            count += n;
        } finally {
            lock.unlock(); //释放锁
        }
    }
}

十、Condition

Condition对象可在ReentrantLock实现wait和notify的功能。

class TaskQueue {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private Queue<String> queue = new LinkedList<>();

    public void addTask(String s) {
        lock.lock();
        try {
            queue.add(s);
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public String getTask() {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                condition.await();
            }
            return queue.remove();
        } finally {
            lock.unlock();
        }
    }
}

  • await()会释放当前锁，进入等待状态；

  • signal()会唤醒某个等待线程；

  • signalAll()会唤醒所有等待线程；

十一、 ReadWriteLock

从名称翻译读写锁，那么有什么用处呢？

  • 只允许一个线程写入（其他线程既不能写入也不能读取）；
  • 没有写入时，多个线程允许同时读（提高性能）。
public class Counter {
    private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
    private final Lock rlock = rwlock.readLock();
    private final Lock wlock = rwlock.writeLock();
    private int[] counts = new int[10];

    public void inc(int index) {
        wlock.lock(); // 加写锁
        try {
            counts[index] += 1;
        } finally {
            wlock.unlock(); // 释放写锁
        }
    }

    public int[] get() {
        rlock.lock(); // 加读锁
        try {
            return Arrays.copyOf(counts, counts.length);
        } finally {
            rlock.unlock(); // 释放读锁
        }
    }
}

把读写操作分别用读锁和写锁来加锁，在读取时，多个线程可以同时获得读锁，这样就大大提高了并发读的执行效率。

使用ReadWriteLock时，适用条件是同一个数据，有大量线程读取，但仅有少数线程修改。

十二、StampedLock

StampedLock和ReadWriteLock相比，改进之处在于：读的过程中也允许获取写锁后写入！这样一来，我们读的数据就可能不一致，所以，需要一点额外的代码来判断读的过程中是否有写入，这种读锁是一种乐观锁。

乐观锁和悲观锁是两种思想，用于解决并发场景下的数据竞争问题。

  • 乐观锁：乐观锁在操作数据时非常乐观，认为别人不会同时修改数据。因此乐观锁不会上锁，只是在执行更新的时候判断一下在此期间别人是否修改了数据：如果别人修改了数据则放弃操作，否则执行操作。
  • 悲观锁：悲观锁在操作数据时比较悲观，认为别人会同时修改数据。因此操作数据时直接把数据锁住，直到操作完成后才会释放锁；上锁期间其他人不能修改数据。
public class Point {
    private final StampedLock stampedLock = new StampedLock();

    private double x;
    private double y;

    public void move(double deltaX, double deltaY) {
        long stamp = stampedLock.writeLock(); // 获取写锁
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            stampedLock.unlockWrite(stamp); // 释放写锁
        }
    }

    public double distanceFromOrigin() {
        long stamp = stampedLock.tryOptimisticRead(); // 获得一个乐观读锁
        // 注意下面两行代码不是原子操作
        // 假设x,y = (100,200)
        double currentX = x;
        // 此处已读取到x=100，但x,y可能被写线程修改为(300,400)
        double currentY = y;
        // 此处已读取到y，如果没有写入，读取是正确的(100,200)
        // 如果有写入，读取是错误的(100,400)
        if (!stampedLock.validate(stamp)) { // 检查乐观读锁后是否有其他写锁发生
            stamp = stampedLock.readLock(); // 获取一个悲观读锁
            try {
                currentX = x;
                currentY = y;
            } finally {
                stampedLock.unlockRead(stamp); // 释放悲观读锁
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

和ReadWriteLock相比，写入的加锁是完全一样的，不同的是读取。注意到首先我们通过tryOptimisticRead()获取一个乐观读锁，并返回版本号。接着进行读取，读取完成后，我们通过validate()去验证版本号，如果在读取过程中没有写入，版本号不变，验证成功，我们就可以放心地继续后续操作。如果在读取过程中有写入，版本号会发生变化，验证将失败。在失败的时候，我们再通过获取悲观读锁再次读取。由于写入的概率不高，程序在绝大部分情况下可以通过乐观读锁获取数据，极少数情况下使用悲观读锁获取数据。

十三、线程池

Java标准库提供了ExecutorService接口表示线程池，它的典型用法如下：

// 创建固定大小的线程池:
ExecutorService executor = Executors.newFixedThreadPool(3);
// 提交任务:
executor.submit(task1);
executor.submit(task2);
executor.submit(task3);
executor.submit(task4);
executor.submit(task5);
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池:
        ExecutorService es = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 6; i++) {
            es.submit(new Task("" + i));
        }
        // 关闭线程池:
        es.shutdown();
    }
}

class Task implements Runnable {
    private final String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("start task " + name);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }
        System.out.println("end task " + name);
    }
}

limitless_mfk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池
fll980205的博客
08-20 823
·为什么要使用线程池？ 使用线程池是为了节省资源，如果每次有任务要来执行，每次都重新创建一个线程，使用完之后再销毁，创建和销毁线程池的代价是很大的，这很划算不来；所以才引进了线程池； 且使用了线程池后，如果当有任务进来时，如果此时线程池内有空闲线程可以来处理该任务，那么就可以直接执行该任务，不用再等待创建线程池了； ·线程池的使用 public ThreadPoolExecutor(int cor...
4.线程池详解
你好啊cbw
02-11 1268
目录 线程池 1.为什么使用线程池(优势) 2.线程池底层原理 3.几种线程池如何工作的？ 4.几种线程池的使用Demo 5.使用线程池好处 线程池 1.为什么使用线程池(优势) 我们使用线程的时候就去创建一个线程，这样实现起来非常简单， 但是就会出现一个问题:如果并发的线程数量很多，并且每一个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是继续执行其它
java中的多线程1.基础知识
zb_andy_j的博客
09-10 166
线程 1.进程和线程的区别 进程是计算机分配资源的最小单元。每个进程的内存空间是相互独立的。 线程是计算机执行调度的最小单元。进程下的线程共用改进程的内存空间。 2.创建以及启动线程 继承Thead public class Create01 extends Thread { @Override public void run() { System.out.println("XXX extends Thread"); } public static void main(Stri
关于JAVA中的线程池
weixin_59937976的博客
10-09 404
java中有四种线程池： 一，缓存线程池： 1，判断有无空闲的进程； 2，存在则使用线程； 3，不存在则重新新增线程放入线程池，线程池无限制大小，并使用该线程； ExecutorService service = Executors.newCachedThreadPool(); //向线程池中 加入 新的任务 service.execute(new Runnable() { @Override public void run(...
java四大线程池
weixin_42481364的博客
09-03 585
线程池的好处 降低资源消耗、提高响应速度、提高线程的可管理性。 缓存线程池CahcedThreadPool 长度无限制。 执行流程： 判断线程池是否存在空闲线程。 存在则使用。 不存在，则创建线程，放入线程池，然后使用。 定长线程池FixedThreadPool 长度是指定数值 任务加入后的执行流程： 判断线程池是否存在空闲线程。 存在则使用。 不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池，然后使用。 不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程。
Java线程 学习
03-03
很好的线程学习资料.。含有部分源代码。
java线程学习
09-18
本教程适用于拥有丰富Java 语言应用知识，但又没有多少多线程或并发性经验的 Java 程序员。 学习完本教程之后，您应该可以编写一个使用线程的简单程序。您还应该可以阅读并理解以简单方 法使用线程的程序。
Java线程学习和总结
03-16
NULL 博文链接：https://ralf-realman.iteye.com/blog/417416
ThreadPoolExecutor 如何判断空闲线程
热门推荐
u011878487的专栏
06-14 1万+
Worker public void run() {            runWorker(this); }        while (task != null || (task = getTask()) != null) { Runnable r = timed ?                    workQueue.poll(keepAliveTime, TimeUnit.NANO...
基于线程池ThreadPoolExecutor参数的大致理解
ggbyyds的博客
04-27 258
基于ThreadPoolExecutor 的参数大致理解
关于线程池的常见问题
weixin_54535063的博客
09-13 1557
线程池的工作队列 线程池的状态 为什么要使用线程池 四，常见线程池有哪些以及使用场景 三，线程池的执行流程 二，线程池的核心参数
怎么设计线程池，怎么判断一个线程是否空闲，谁来判断？
qq_52896055的博客
08-02 443
线程池会根据任务队列的容量和线程池的大小来决定是否创建新的线程来执行任务，或者将任务放入队列等待执行。线程池会根据任务队列的状态来判断是否有空闲线程可用，如果有，则将任务分配给空闲线程执行。4.执行任务，线程池会自动从任务队列中取出任务，并将其分配给空闲的线程执行。线程池会根据任务的优先级和调度策略来决定任务的执行顺序。线程池的大小决定线程池中可以同时执行的线程的数量，任务队列的容量决定可以等待执行的线程数量。1.确定线程池，线程池的大小应该根据系统的处理能力和任务的类型来确定，避免线程过多或过少。
Java中的四种线程池
jianshixiyy的博客
03-14 233
线程池 Executors 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. **线程池**就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。 一、线程池的好处 降低资源消耗。 提高响应速度。 提高线程的可管理性。 二、四种线程池 . ExecutorService 1. 缓存线程池 /** * 缓存线程池. * (长度无限制) * 执行流程:
线程池笔记
金牛区代码仔的博客
08-05 257
shutdown()：遍历workers，调用tryLock()判断线程是否空闲，是空闲，则调用interrupt()方法中断线程。shutdownNow()：不会调用tryLock()，而是直接调用interruptWorkers();tryLock()方法核心也是cas操作，尝试将线程的状态变量从0变成1，操作成功返回true，失败返回false。步骤⼀：判断当前线程数是否⼤于或等于corePoolSize。调用其tryLock()方法，如果没获取到锁，表示线程在忙，如果获取到了锁，表示线程是空闲的。.
java线程池原理分析及状态说明
u012758488的博客
08-30 1010
ThreadPoolExecutor Executor框架的最顶层实现是ThreadPoolExecutor类，Executors工厂类中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其实也只是ThreadPoolExecutor的构造函数参数不同而已。通过传入不同的参数，就可以构造出适用于不同应用场景下的线程池，那么它的底层原理是怎样实现的呢，这篇就来介绍下ThreadPoolExecutor线程池的运行过程。 co
Java中的线程池的线程数量如何确定？
m0_67698950的博客
09-01 1449
线程池是一种“池化”的线程使用模式，通过创建一定数量的线程，让这些线程处于就绪状态来提高系统响应速度，在线程使用完成后归还到线程池来达到重复利用的目标，从而降低系统资源的消耗。
java多线程 学习
最新发布
04-19
Java多线程是指在Java程序中同时执行多个线程的机制。通过使用多线程，可以实现并发执行，提高程序的效率和响应性。在Java中，可以通过以下几种方式来实现多线程： 1. 继承Thread类：创建一个继承自Thread类的子类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值