并发编程-线程

  • 什么是线程

  • 如何创建线程

  • 继承 Thread 类

  • 实现 Runnable 接口

  • 使用 Callable 和 Future 接口

  • 线程的状态

  • 1. 新建状态

  • 2. 就绪状态

  • 3. 运行状态

  • 4. 阻塞状态

  • 5. 终止状态

  • 线程同步

  • 线程同步的方式

  • synchronized关键字

  • Lock接口

  • 线程同步的其他问题

  • 竞态条件

  • 死锁

  • 饥饿

  • 线程死亡

  • 线程通信

  • wait()和notify()方法

  • CountDownLatch

  • CyclicBarrier

  • Semaphore

  • 线程池

  • 线程池的组成

  • 线程池的参数

  • 线程池的工作流程

  • 线程池的优缺点

  • 线程池的最佳实践

  • 线程安全性问题

  • 什么是线程安全？

  • 线程安全的技术手段

  • 同步方法和同步块

  • 原子类

  • 锁

  • 信号量

  • 条件变量

  • 并发集合类

  • 线程安全的最佳实践

  • 避免使用共享变量

  • 使用不可变对象

  • 同步共享资源

  • 使用并发集合类

  • 避免死锁和饥饿

  • 总结

人生没有如果，只有后果和结果。

线程

什么是线程

  • 线程是计算机中的基本执行单元，是程序执行的流程，是操作系统分配资源的基本单位

  • 线程的作用：提高程序的并发性，提高CPU的利用率

  • 线程的分类：用户线程和守护线程

如何创建线程

在 Java 中，有三种常用的创建线程的方式：

  • 继承 Thread 类

  • 实现 Runnable 接口

  • 使用 Callable 和 Future 接口

继承 Thread 类

继承 Thread 类是最基本的创建线程的方式之一。步骤如下：

  1. 定义一个类继承 Thread 类，并重写 run 方法

  2. 在 run 方法中实现需要执行的代码

  3. 调用 start 方法启动线程

示例代码：

public class MyThread extends Thread {
    @Override
    public void run() {
        // 需要执行的代码
    }
}

// 创建并启动线程
MyThread myThread = new MyThread();
myThread.start();

这种方式的优点是简单直接，容易理解和上手，但是如果需要继承其他类或者实现其他接口，就无法再使用这种方式创建线程。

实现 Runnable 接口

实现 Runnable 接口是另一种创建线程的方式。步骤如下：

  1. 定义一个类实现 Runnable 接口，并重写 run 方法

  2. 在 run 方法中实现需要执行的代码

  3. 创建 Thread 对象，将 Runnable 对象作为参数传入 Thread 的构造方法中

  4. 调用 start 方法启动线程

示例代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 需要执行的代码
    }
}

// 创建并启动线程
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

这种方式的优点是可以避免单继承的限制，同时也可以实现资源共享，缺点是比较繁琐。

使用 Callable 和 Future 接口

使用 Callable 和 Future 接口是一种更加灵活的创建线程的方式。步骤如下：

  1. 定义一个类实现 Callable 接口，并重写 call 方法

  2. 在 call 方法中实现需要执行的代码

  3. 创建 ExecutorService 对象，调用 submit 方法提交 Callable 对象

  4. 调用 Future 对象的 get 方法获取 Callable 的返回值

示例代码：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 需要执行的代码
        return "result";
    }
}

// 创建 ExecutorService 对象
ExecutorService executorService = Executors.newSingleThreadExecutor();

// 提交任务并获取 Future 对象
Future<String> future = executorService.submit(new MyCallable());

// 获取任务的返回值
String result = future.get();

// 关闭线程池
executorService.shutdown();

这种方式的优点是可以返回执行结果，可以抛出异常，缺点是相对于其他方式更加复杂。

创建线程的方式需要根据实际情况来考虑。如果只是简单的多线程操作，继承 Thread 类或实现 Runnable 接口即可；如果需要返回结果或抛出异常，则需要使用 Callable 和 Future 接口。

命就像一朵花，它需要你给它爱，
才能绽放出它最美丽的色彩.

线程的状态

Java中的线程状态是指线程在运行过程中所处的状态，可以分为以下五种状态：

1. 新建状态

线程对象被创建后，但是还没有调用start()方法启动线程时，线程处于新建状态。此时线程的状态可以通过getState()方法获取，通常为NEW。在新建状态下，线程还没有被分配CPU资源，因此不会执行任何任务。

2. 就绪状态

当线程调用start()方法后，线程进入就绪状态。在就绪状态下，线程已经准备好了，等待CPU调度执行。此时线程的状态可以通过getState()方法获取，通常为RUNNABLE。在就绪状态下，线程已经被分配了CPU资源，但是还没有开始执行任务。

3. 运行状态

当线程获得CPU时间片，开始执行任务时，线程进入运行状态。此时线程的状态可以通过getState()方法获取，通常为RUNNABLE。在运行状态下，线程正在执行任务，占用CPU资源。

4. 阻塞状态

当线程等待某个条件，例如IO操作、等待获取锁时，线程将进入阻塞状态。在阻塞状态下，线程不会占用CPU资源，因此也不会执行任务。当线程等待的条件满足时，线程将进入就绪状态，等待CPU调度执行。此时线程的状态可以通过getState()方法获取，通常为BLOCKED。

5. 终止状态

线程执行完run()方法后，或者异常终止，线程进入终止状态。线程一旦进入终止状态就不能再进入其他状态。此时线程的状态可以通过getState()方法获取，通常为TERMINATED。在终止状态下，线程已经完成了任务，不再占用CPU资源。

线程状态的变化由JVM调度器负责，程序员可以通过Thread类提供的一些方法来观察和控制线程的状态。例如：

  • getState()方法：获取线程的状态。

  • sleep()方法：使当前线程休眠指定的时间。

  • yield()方法：让出当前线程所占用的CPU资源，让其他线程执行。

  • join()方法：等待其他线程执行完毕再执行当前线程。

  • interrupt()方法：中断线程的执行。

  • setPriority()方法：设置线程的优先级。

了解线程状态的变化可以更好地控制线程的执行，避免出现死锁、饥饿等问题

除了上述五种状态，Java中还有一种特殊的状态，即TIMED_WAITING状态。当线程调用sleep()方法或wait()方法时，线程将进入TIMED_WAITING状态。在这种状态下，线程不会占用CPU资源，直到指定的时间到达或者被其他线程唤醒，才会进入就绪状态。

把握机会，改变自己，也许你会发现，
前方的风景更加美丽。

线程同步

多个线程同时访问同一个资源时，如果不加以协调，可能会导致数据的不一致性，这就是线程安全性问题。为了解决这个问题，需要对多个线程之间的访问加以协调，这就是线程同步。

线程同步的方式

Java中线程同步的方式主要有两种，一种是使用synchronized关键字，另一种是使用Lock接口。

synchronized关键字

synchronized关键字可以保证同一时刻只有一个线程访问共享资源。synchronized关键字可以用于方法、代码块等多种场景。在使用synchronized关键字时，需要注意以下原则：

  • 保证锁定的是共享资源，而不是私有资源。

  • 尽量减小锁的粒度。

  • 避免死锁和饥饿问题。

Lock接口

Lock接口是JDK1.5中引入的新特性，与synchronized关键字类似，也可以用于线程同步。相比于synchronized关键字，Lock接口具有以下优点：

  • 可以选择公平锁和非公平锁。

  • 可以实现多个条件变量。

  • 可以避免死锁问题。

在使用Lock接口时，需要注意以下原则：

  • 在finally块中释放锁。

  • 避免使用锁定过长时间的代码块。

  • 避免使用重入锁。

线程同步的其他问题

线程同步不仅涉及到同步的方式，还涉及到一些其他的问题，例如竞态条件、死锁、饥饿等问题。

竞态条件

竞态条件指的是多个线程执行的顺序不确定，导致结果的不确定性。例如，当多个线程同时对一个变量进行自增操作时，结果可能会出现错误。

死锁

死锁指的是多个线程互相等待对方释放资源，导致所有的线程都无法继续执行。例如，当线程A持有锁1，等待锁2，而线程B持有锁2，等待锁1时，就会出现死锁。

饥饿

饥饿指的是某个线程长时间无法获得所需的资源，导致一直无法执行。例如，当一个线程一直无法获得锁，就会一直处于饥饿状态。

线程死亡

线程死亡可以通过调用stop()方法或者run()方法结束，但是这两种方法都不推荐使用。正确的方式是让线程自然死亡，即让线程的run()方法正常执行完毕。

了解线程同步的方式和问题可以更好地控制线程的执行，避免出现线程安全性问题。在多线程编程中，确保线程同步合理，避免出现竞态条件和线程安全问题

此外，还需要考虑一些其他的问题，例如性能、可扩展性、代码复杂度等。因此，选择合适的线程同步方式和解决方案，需要综合考虑多个因素，才能得到最优的结果。

努力可以改变命运，自信可以改变一切。

线程通信

多个线程协调完成一个任务，需要通过线程间通信来实现。Java中提供了多种线程间通信方式，例如：wait()和notify()方法，CountDownLatch等。下面将介绍其中一些常用的线程间通信方式。

wait()和notify()方法

wait()和notify()方法是Java中最基本的线程间通信方式。wait()方法可以使调用线程进入等待状态，直到其他线程调用notify()方法唤醒该线程。notify()方法可以唤醒一个等待该对象锁的线程。使用wait()和notify()方法实现线程间通信的步骤如下：

  1. 在共享资源上加锁，避免多个线程同时访问。

  2. 线程A调用wait()方法进入等待状态，释放锁。

  3. 线程B获取锁，修改共享资源。

  4. 线程B调用notify()方法唤醒线程A。

  5. 线程B释放锁。

使用wait()和notify()方法实现线程间通信的优点是简单易用，缺点是只能唤醒一个等待线程。

CountDownLatch

CountDownLatch是Java中的一个同步工具类，它可以实现线程间的等待和唤醒。使用CountDownLatch实现线程间通信的步骤如下：

  1. 创建CountDownLatch对象，设置需要等待的线程数。

  2. 多个线程调用await()方法进入等待状态。

  3. 另一个线程调用CountDownLatch对象的countDown()方法进行计数，直到计数器为0时，所有等待线程被唤醒。

CountDownLatch的优点是可以唤醒多个等待线程，缺点是计数器只能使用一次。

CyclicBarrier

CyclicBarrier是Java中的另一个同步工具类，它也可以实现线程间的等待和唤醒。使用CyclicBarrier实现线程间通信的步骤如下：

  1. 创建CyclicBarrier对象，设置需要等待的线程数和等待完成后需要执行的任务。

  2. 多个线程调用await()方法进入等待状态。

  3. 当所有等待线程都到达屏障点时，执行指定的任务。

CyclicBarrier的优点是可以重复使用，缺点是所有等待线程必须同时到达屏障点。

Semaphore

Semaphore是Java中的另一个同步工具类，它可以控制同时访问某个资源的线程数。使用Semaphore实现线程间通信的步骤如下：

  1. 创建Semaphore对象，设置允许同时访问的线程数。

  2. 多个线程调用acquire()方法获取许可证，如果许可证数量为0，则线程进入等待状态。

  3. 当某个线程不再需要访问资源时，调用release()方法释放许可证。

Semaphore的优点是可以控制并发访问数量，缺点是需要手动释放许可证。

根据实际情况选择合适的方式来实现线程间通信。在实际开发中，需要注意线程安全性问题，避免出现死锁、饥饿等问题，保证程序的正确性和稳定性。同时，需要根据具体需求选择合适的同步工具类，避免出现线程安全性问题。

每一次跌倒，都是为了学会爬起来的勇气。

线程池

线程池是一种用于管理和复用线程的机制，可以优化多线程应用程序的性能和稳定性。线程池可以避免频繁创建和销毁线程的开销，同时可以限制并发线程的数量，避免资源过度占用。Java中提供了ThreadPoolExecutor类作为线程池的实现，同时也提供了Executors类作为线程池的工厂，使得可以更加快速地创建线程池。

线程池的组成

Java线程池由以下四个部分组成：

  • 任务队列（Task Queue）：用于存放等待执行的任务。线程池中的任务可以是Runnable接口或者Callable接口的实现。

  • 工作线程（Worker Threads）：用于执行任务的线程。线程池中的每个线程都会执行任务队列中的任务，直到任务队列为空。

  • 线程池管理器（ThreadPool Manager）：用于管理工作线程和任务队列。线程池管理器负责创建新的线程和销毁闲置的线程，同时也负责将任务添加到任务队列中。

  • 任务（Task）：需要执行的任务。任务可以是Runnable接口或者Callable接口的实现，可以通过execute()方法提交到线程池中执行。

线程池的参数

Java线程池的参数包括以下几个：

  • corePoolSize：线程池中的核心线程数。当线程池中的线程数少于核心线程数时，新任务会创建新线程来执行，即使其他线程处于空闲状态。

  • maximumPoolSize：线程池中的最大线程数。当线程池中的线程数等于最大线程数时，新的任务会被添加到任务队列中等待执行。

  • keepAliveTime：非核心线程的超时时间。当线程池中的线程数大于核心线程数，而且有一些线程处于空闲状态超过了设定的超时时间，那么这些线程将被销毁。

  • unit：keepAliveTime的单位。

  • workQueue：用于存放等待执行的任务的队列。任务队列可以是有界队列或者无界队列，有界队列的大小可以通过构造函数或者工厂方法进行设置。

  • threadFactory：用于创建新线程的工厂。可以通过实现ThreadFactory接口自定义线程的创建方式，例如设置线程的名称、线程的优先级等。

  • handler：当任务无法执行时的处理策略。可以通过实现RejectedExecutionHandler接口自定义任务无法执行时的处理策略，例如抛出异常或者丢弃任务。

线程池的工作流程

Java线程池的工作流程如下：

  1. 当一个任务提交到线程池时，线程池会检查当前核心线程数是否已满，如果没有满，则创建一个新线程执行该任务，否则将该任务加入到任务队列中等待执行。

  2. 当任务队列已满时，线程池会检查当前非核心线程数是否已满，如果没有满，则创建一个新线程执行该任务，否则根据指定的策略进行处理，例如抛出异常或者丢弃任务。

  3. 当一个线程完成任务后，会从任务队列中取出下一个任务执行，如果任务队列为空，则该线程会等待新任务的到来。

  4. 如果线程池中的线程数超过了核心线程数，而且有一些线程处于空闲状态超过了设定的超时时间，那么这些线程将被销毁。

线程池的优缺点

Java线程池的优点包括：

  • 降低线程的创建和销毁开销。线程的创建和销毁是非常耗费资源的操作，通过线程池可以避免频繁创建和销毁线程，从而降低资源的占用。

  • 限制线程数量，避免资源过度占用。线程池可以限制并发线程的数量，避免资源过度占用，从而提高系统的稳定性和可靠性。

  • 提高程序的响应速度和稳定性。线程池可以提高程序的响应速度和稳定性，因为线程池中的线程可以复用，从而避免了频繁的创建和销毁线程的开销。

  • 可以灵活调整线程池的参数，以适应不同的应用场景。线程池的参数可以根据具体应用场景进行调整，例如核心线程数、最大线程数、任务队列、超时时间等。

Java线程池的缺点包括：

  • 任务无法取消。一旦任务被提交到线程池中执行，就无法取消，这可能会导致一些问题，例如内存泄漏或者资源浪费。

  • 任务的执行顺序不确定。线程池中的任务的执行顺序是不确定的，这可能会导致一些问题，例如死锁或者数据竞争。

  • 线程池的参数设置需要根据具体应用场景进行调整。线程池的参数设置需要根据具体应用场景进行调整，如果设置不当，可能会导致资源过度占用或者任务无法执行等问题。

线程池的最佳实践

在使用线程池时，需要注意以下几点：

  • 应该避免使用Executors类创建线程池，因为它的默认参数可能不适合所有应用场景。应该直接使用ThreadPoolExecutor类创建线程池，并根据具体应用场景调整线程池的参数。

  • 应该根据具体应用场景调整线程池的参数，例如核心线程数、最大线程数、任务队列、超时时间等。应该根据具体应用场景进行调整，避免资源过度占用、任务无法取消等问题。

  • 应该使用Callable接口代替Runnable接口，因为它可以返回执行结果，方便进行错误处理和结果处理。使用Callable接口需要使用submit()方法提交任务。

  • 应该使用Future接口来获取任务执行的结果，可以异步地获取任务的执行结果，避免阻塞主线程。可以使用submit()方法返回Future对象，通过Future对象获取任务的执行结果。

  • 应该使用CompletionService类来批量执行任务，可以提高程序的并发度和效率。CompletionService类可以异步地获取任务的执行结果，并且可以批量执行任务。

在使用线程池时，需要根据具体应用场景调整线程池的参数，避免出现资源过度占用、任务无法取消等问题。同时，还需要注意使用Callable接口和Future接口获取任务执行的结果，使用CompletionService类批量执行任务等最佳实践。

生活就像一杯茶，不会苦一辈子，
但要让它熬出香味来，就得慢慢熬。

线程安全性问题

什么是线程安全？

线程安全是指当多个线程访问同一个共享资源时，不会出现不正确的结果或者不可预期的结果。线程安全是多线程编程中的一个重要问题，需要考虑并发访问的情况，避免出现数据竞争、死锁、饥饿等问题。

线程安全的技术手段

Java中提供了多种技术手段来实现线程安全，主要包括以下几种：

同步方法和同步块

使用synchronized关键字来实现同步，保证同一时刻只有一个线程可以访问共享资源。同步方法和同步块可以保证线程安全，但是可能会降低程序的性能。

原子类

使用Atomic包中的原子类来实现线程安全的操作，例如AtomicInteger、AtomicBoolean、AtomicLong等。原子类可以保证线程安全，同时不会降低程序的性能。

锁

使用Lock接口和ReentrantLock类来实现锁机制，支持更加灵活的线程同步，例如可重入锁、公平锁、读写锁等。使用锁可以实现更加细粒度的线程同步，但是需要注意避免死锁和饥饿等问题。

信号量

使用Semaphore类来实现线程间的信号量控制，可以限制并发访问数量。使用信号量可以控制线程的并发度，避免出现资源过度占用的问题。

条件变量

使用Condition接口和实现类来实现线程间的等待和通知机制，可以更加灵活地控制线程的同步。使用条件变量可以实现更加复杂的线程同步和通信。

并发集合类

使用Java中提供的并发集合类，例如ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList等，可以在多线程环境下安全地访问集合类。使用并发集合类可以避免出现数据竞争等问题。

线程安全的最佳实践

在实际开发中，需要注意以下几点来保证线程安全：

避免使用共享变量

共享变量容易引起数据竞争和死锁等问题，可以使用线程本地变量或者消息传递等方式避免共享变量的使用。

使用不可变对象

不可变对象是指创建之后不可修改的对象，例如String、Integer等。使用不可变对象可以避免出现数据竞争和死锁等问题。

同步共享资源

对于需要共享的资源，使用同步方法、同步块、锁等机制来实现线程安全的访问。

使用并发集合类

Java中提供了多种并发集合类，可以安全地在多线程环境下访问集合类。

避免死锁和饥饿

死锁和饥饿是线程安全性的常见问题，需要避免出现这些问题，保证程序的正确性和稳定性。

在实际开发中，需要根据具体应用场景选择合适的线程安全技术手段，保证程序的正确性和稳定性。同时，需要注意线程安全的最佳实践，避免出现数据竞争、死锁、饥饿等问题。

每一个不曾放弃的人，都有一个不可思议的结局。

总结

在这篇文章中，我们介绍了Java线程的创建,状态,同步,通信,安全，线程池。同时阐述了他们的实现方式，优缺点，注意事项和最佳实践，在实际开发中，我们需要根据具体应用场景选择合适的线程池参数和线程安全技术手段，以避免出现数据竞争、死锁、饥饿等问题。希望这篇文章对您有所帮助！

posted @ 2023-03-12 03:27  无回实验室  阅读(27)  评论(0)  编辑  收藏  举报