入门Java线程基础一篇就够了

来讲解一下“入门Java线程基础一篇就够了”的攻略吧。

1. Java线程基础概念

1.1 什么是线程？

简单来说，线程是程序执行的一个单独的流程或执行单元。在Java中，每一个线程都是通过Thread类来创建和管理的。

1.2 如何创建一个线程？

Java中创建线程的方式有两种：

• 继承Thread类，重写run()方法。
• 实现Runnable接口。

示例1：继承Thread类创建线程

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

public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread myThread = new MyThread();
        // 启动线程
        myThread.start();
    }
}

示例2：实现Runnable接口创建线程

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

public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread myThread = new Thread(new MyRunnable());
        // 启动线程
        myThread.start();
    }
}

1.3 线程的状态

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

• NEW（新建状态）：线程已经被创建，但还未被启动。
• RUNNABLE（运行状态）：线程正在被执行。
• BLOCKED（阻塞状态）：线程被某些操作（如I/O操作、等待获取锁等）所阻塞，暂时停止执行。
• WAITING（等待状态）：线程等待某个条件的触发，暂时不运行。
• TIMED_WAITING（计时等待状态）：线程等待某个条件的触发，但只等待一定的时间，超时后会自动唤醒。
• TERMINATED（终止状态）：线程已经执行结束，不再运行。

1.4 线程同步

在多线程环境中，线程之间可能会出现数据竞争（即多个线程对同一个数据进行读写操作，导致数据的不一致）。为了避免这种情况，我们需要进行线程同步。

Java中提供了以下两种线程同步机制：

• synchronized关键字：通过加锁的方式实现线程同步。
• Lock接口：通过Lock和Condition接口实现线程同步。

示例3：使用synchronized关键字实现线程同步

public class Counter {
    private int count;

    public synchronized void increment() {
        // 对count进行加1操作，同步操作确保了操作结果的正确性
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> counter.increment()).start();
        }
        // 在所有线程执行完之后输出count的值
        System.out.println(counter.getCount());
    }
}

2. Java线程高级概念

2.1 线程池

Java中的线程池是一种线程管理方式，它会在程序启动时创建一定数量的线程，并且将这些线程保存在池中。当程序需要创建新的线程时，可以从池中获取可用的线程，而不是新建一个线程，这样可以减少线程的创建和销毁的开销，提高程序的性能。

Java中提供了以下线程池类型：

• FixedThreadPool：固定大小的线程池，可重复利用线程。
• CachedThreadPool：可缓存的线程池，适用于执行大量短期的任务。
• SingleThreadExecutor：单线程化的线程池，只有一个线程在工作。

示例4：使用线程池执行任务

public class MyTask implements Runnable {
    private int num;

    MyTask(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        System.out.println("Task " + num + " is running.");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task " + num + " is completed.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个FixedThreadPool类型的线程池，最多创建3个线程
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 提交10个任务给线程池执行
        for (int i = 0; i < 10; i++) {
            executorService.execute(new MyTask(i));
        }
        // 关闭线程池
        executorService.shutdown();
    }
}

2.2 线程安全的集合

在多线程环境中，Java集合类（如ArrayList、HashMap等）可能会出现线程安全问题。为了避免这种情况，Java提供了一些线程安全的集合类来实现多线程环境下的数据操作。

Java中提供了以下线程安全的集合类：

• ConcurrentHashMap：线程安全的HashMap。
• CopyOnWriteArrayList：线程安全的ArrayList。
• BlockingQueue：线程安全的队列，支持阻塞操作。

示例5：使用线程安全的集合来处理数据

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个线程安全的ConcurrentHashMap对象
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        // 创建两个线程对map进行读写操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                map.put("num", i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                System.out.println(map.get("num"));
            }
        });
        // 启动两个线程
        t1.start();
        t2.start();
        // 等待两个线程执行完毕
        t1.join();
        t2.join();
    }
}

好了，以上就是入门Java线程基础的攻略啦~