当前位置：极客笔记 > Java > Java 问答 > Java多线程编程

Java多线程编程

Java多线程编程

Java多线程编程

简介

多线程编程是指在同一时间内执行多个线程，使得程序具有并发性。在Java中，多线程编程是一种常见的编程方式，能够充分利用计算机的多核心处理器，提高程序的性能和响应速度。

在Java中，可以通过继承Thread类或者实现Runnable接口来创建线程。通过使用线程池或者使用同步机制来处理线程间的通信和同步。

本文将详细介绍Java多线程编程的基础知识、线程的创建与启动、线程的状态控制、线程的同步与通信等内容。

基础知识

什么是线程

线程是操作系统进行任务调度的基本单位。一个进程可以包含多个线程，每个线程可以独立执行不同的任务。线程的特点包括独立性、并发性和共享性。

在Java中，线程是通过java.lang.Thread类来表示的。一个线程对象对应着一个独立执行的线程。

线程的状态

在Java中，线程有以下几种状态：

  • 新建状态（New）：通过new关键字来创建一个线程对象，但是还没有调用start()方法启动线程。
  • 运行状态（Runnable）：线程被启动之后，开始执行run()方法，进入运行状态。
  • 阻塞状态（Blocked）：线程因为某种原因被阻塞，等待某个条件的满足或者资源的释放。
  • 等待状态（Waiting）：线程处于等待状态，等待其他线程的通知或者中断。
  • 超时等待状态（Timed Waiting）：线程在一定时间内等待，超时后自动唤醒。
  • 终止状态（Terminated）：线程执行完毕或者发生异常，进入终止状态。

线程的优先级

Java中线程的优先级范围是1~10，其中1为最低优先级，10为最高优先级。线程的优先级可以通过setPriority()方法进行设置。

在大多数操作系统中，线程的优先级设置对于线程的调度并不会有明显的影响。不过，在某些特定场景下，设置线程的优先级可以有助于提高程序性能。

线程的创建与启动

继承Thread类

通过继承Thread类来创建线程，需要重写run()方法，并在run()方法中定义线程的执行逻辑。然后通过调用start()方法启动线程。

示例代码：

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

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

运行结果：

Thread is running

实现Runnable接口

除了继承Thread类，还可以通过实现Runnable接口来创建线程。实现Runnable接口相比继承Thread类更加灵活，可以避免单继承的限制。

示例代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

运行结果：

Thread is running

线程的状态控制

线程的睡眠

可以通过Thread.sleep()方法让线程进入睡眠状态，指定睡眠时间后自动唤醒。

示例代码：

public class SleepThread {
    public static void main(String[] args) {
        System.out.println("Thread is running");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread is finished");
    }
}

运行结果：

Thread is running
Thread is finished

线程的加入

可以通过Thread.join()方法让一个线程等待另一个线程的结束。

示例代码：

public class JoinThread {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread1 is running");
        });

        Thread thread2 = new Thread(() -> {
            try {
                thread1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread2 is running");
        });

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

运行结果：

Thread1 is running
Thread2 is running

线程的同步与通信

synchronized关键字

Java中的synchronized关键字可以用来实现线程同步，它可以修饰方法或代码块。在一个线程访问synchronized方法或代码块时，其他线程必须等待。

示例代码：

public class SyncThread {
    private static int count = 0;

    public synchronized static void increment() {
        count++;
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + count);
    }
}

运行结果：

Count: 2000

使用Lock实现同步

除了synchronized关键字，Java还提供了Lock接口来实现同步。Lock接口的实现类ReentrantLock可以显式地控制线程的同步。

示例代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockThread {
    private static int count = 0;
    private static Lock lock = new ReentrantLock();

    public static void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + count);
    }
}

运行结果：

Count: 2000

线程通信

线程通信是指多个线程之间的协作，实现线程之间的数据传递和同步。在Java中，可以使用wait()、notify()和notifyAll()方法来实现线程间的通信。

示例代码：

public class ThreadCommunication {
    private static final Object lock = new Object();
    private static boolean flag = false;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                while(!flag) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("Thread1 is running");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread2 is running");
                flag = true;
                lock.notify();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

Thread2 is running
Thread1 is running

线程池

线程池是一种管理线程的机制，可以重用线程、提高性能和减少资源消耗。Java提供了Executor框架来实现线程池。

创建线程池

可以通过Executors类提供的静态方法来创建不同类型的线程池，如newFixedThreadPool()、newCachedThreadPool()、newSingleThreadExecutor()等。

示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " is running in Thread: " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

运行结果：

Task 1 is running in Thread: pool-1-thread-1
Task 2 is running in Thread: pool-1-thread-2
Task 3 is running in Thread: pool-1-thread-1
Task 4 is running in Thread: pool-1-thread-2
Task 5 is running in Thread: pool-1-thread-1

总结

本文详细介绍了Java多线程编程的基础知识、线程的创建与启动、线程的状态控制、线程的同步与通信、线程池等内容。多线程编程是Java中重要的编程方式之一，在需要提高程序性能和响应速度的场景下，合理地使用多线程能够发挥巨大的作用。开发人员应该熟练掌握多线程编程的相关知识，并注意线程安全和同步机制的实现。

Camera课程

Camera API2 教程

API2 教程
Camera 性能教程

Perf 教程
Camera Native Framework 教程

Native FW 教程
Camera QCOM ISP 教程

ISP 教程
Camera QCOM Sensor 教程

Sensor 教程

Python教程

Python 教程

Python 教程
NumPy 教程

NumPy 教程
Django 教程

Django 教程

Java教程

Java 教程

Java 教程

Web教程

JavaScript 教程

JavaScript 教程
jQuery 教程

jQuery 教程
CSS 教程

CSS 教程
PHP 教程

PHP 教程
Laravel 教程

Laravel 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程

数据库教程

SQL 教程

SQL 教程
SQLite 教程

SQLite 教程
MySQL 教程

MySQL 教程
PL/SQL 教程

PL/SQL 教程
MongoDB 教程

MongoDB 教程

图形图像教程

OpenCV 教程

OpenCV 教程

办公软件教程

Excel 教程

Excel 教程

Linux教程

Linux命令全集

Linux命令全集
Linux内核API

Linux内核API
LVGL 教程

LVGL 教程

计算机教程

操作系统 教程

操作系统 教程
计算机网络 教程

计算机网络 教程
C语言 教程

C语言 教程
C++ 教程

C++ 教程
Swift 教程

Swift 教程

大数据教程

Hadoop 教程

Hadoop 教程
Spark 教程

Spark 教程
Scala 教程

Scala 教程

开发工具教程

Git 教程

Git 教程
Jenkins 教程

Jenkins 教程
ChatGPT 教程

ChatGPT 教程
IntelliJ 教程

IntelliJ 教程

Java 精选教程