正文

Java线程被调用函数：揭秘高效并发编程之道

/0 浏览量
0328

引言

在Java编程中，线程是实现并发编程的关键。通过合理地使用线程，我们可以充分利用多核处理器的性能，提高程序的执行效率。本文将深入探讨Java线程的创建、调度、同步以及常见并发编程模式，帮助读者掌握高效并发编程之道。

一、Java线程的创建与启动

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

1. 实现Runnable接口

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

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

2. 继承Thread类

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

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

二、Java线程的调度

Java线程的调度主要依赖于操作系统的线程调度机制。在Java中，线程的状态分为以下几种：

  • 新建（New）：线程对象创建后尚未启动。
  • 就绪（Runnable）：线程已经获得CPU时间，等待被调度执行。
  • 运行（Running）：线程正在执行。
  • 阻塞（Blocked）：线程因为某些原因无法执行，如等待锁。
  • 等待（Waiting）：线程处于等待状态，等待其他线程的通知。
  • 终止（Terminated）：线程执行完毕。

三、Java线程的同步

在多线程环境中，共享资源可能会出现竞态条件，导致程序出现不可预知的结果。为了解决这个问题，Java提供了线程同步机制。

1. 同步代码块

public class MyThread implements Runnable {
    private static int count = 0;

    @Override
    public void run() {
        synchronized (MyThread.class) {
            count++;
        }
    }
}

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

2. 同步方法

public class MyThread implements Runnable {
    private static int count = 0;

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

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            increment();
        }
    }
}

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

3. Lock接口

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

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

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            lock.lock();
            try {
                count++;
            } finally {
                lock.unlock();
            }
        }
    }
}

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

四、常见并发编程模式

1. 线程池

线程池可以有效地管理线程资源，提高程序的性能。Java提供了ExecutorService接口来实现线程池。

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            executor.execute(new MyThread());
        }
        executor.shutdown();
    }
}

2. Future和Callable

Future和Callable接口可以用于异步执行任务，并获取执行结果。

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

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // 执行任务
                return 1;
            }
        };
        Future<Integer> future = executor.submit(task);
        System.out.println(future.get());
        executor.shutdown();
    }
}

3. 线程安全集合

Java提供了线程安全的集合类，如CopyOnWriteArrayList、ConcurrentHashMap等，可以在多线程环境中安全地使用。

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("key1", 1);
        map.put("key2", 2);
        System.out.println(map.get("key1"));
    }
}

总结

本文介绍了Java线程的创建、调度、同步以及常见并发编程模式。通过掌握这些知识，我们可以编写出高效、稳定的并发程序。在实际开发中，我们需要根据具体需求选择合适的并发编程模式，并注意线程安全问题。

-- 展开阅读全文 --