正文

轻松掌握Java线程创建与并发控制技巧

/0 浏览量
1014

在Java编程中，线程是处理并发任务的基本单位。掌握线程的创建与并发控制技巧对于编写高效、响应迅速的程序至关重要。本文将带领你轻松掌握Java线程的创建方法和并发控制技巧。

一、Java线程的创建

在Java中，创建线程主要有两种方式：通过继承Thread类和实现Runnable接口。

1. 继承Thread类

这是最传统的方式，通过继承Thread类并重写其run方法来定义线程的执行内容。

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

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

2. 实现Runnable接口

这种方式更为灵活，因为你可以将Runnable接口的实现传递给多个线程。

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

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

3. 使用Callable和Future

Callable接口与Runnable类似，但它可以返回一个值，并且可以抛出异常。Future对象可以用来获取Callable的返回值。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 线程执行的代码
        return "Hello, Future!";
    }
}

public class Main {
    public static void main(String[] args) {
        Callable<String> callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            String result = futureTask.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、并发控制技巧

1. 同步块（Synchronized）

同步块可以保证同一时间只有一个线程可以访问某个资源。

public class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

2. 锁（Lock）

java.util.concurrent.locks.Lock接口提供了比synchronized更灵活的锁操作。

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

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

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

    public int getCount() {
        return count;
    }
}

3. 线程安全的数据结构

Java提供了许多线程安全的数据结构，如Vector、CopyOnWriteArrayList等。

import java.util.concurrent.CopyOnWriteArrayList;

public class Main {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("Item 1");
        list.add("Item 2");
        System.out.println(list);
    }
}

4. 线程池（ThreadPool）

使用线程池可以有效地管理线程资源，避免频繁创建和销毁线程。

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}

通过以上方法，你可以轻松地在Java中创建线程，并使用各种并发控制技巧来保证线程安全。希望本文能帮助你更好地掌握Java线程的创建与并发控制技巧。

-- 展开阅读全文 --