Java 多线程与并发编程·Java 工程师必知必会

客官°小女子只卖身不卖艺 2024-03-22 18:19 49阅读 0赞

##  ##

Java 多线程与并发编程是 Java 工程师必须掌握的重要技能之一。随着计算机硬件性能的不断提升，多核 CPU 成为主流，开发高并发应用已成为越来越重要的需求。本文将介绍 Java 多线程与并发编程的基本概念和技术，包括线程、锁、同步机制、线程池、并发集合和并发编程的实践案例。

线程

线程是进程的一部分，是程序执行的最小单位。Java 中的线程是通过 Thread 类实现的。在 Java 中，线程有五个状态：新建状态、就绪状态、运行状态、阻塞状态和终止状态。通常使用 start 方法启动一个新线程，使用 join 方法等待线程执行完毕，使用 sleep 方法暂停线程的执行。以下是一个简单的线程实例：

public class MyThread extends Thread {
      @Override
      public void run() {
          System.out.println("Hello from thread " + Thread.currentThread().getName());
      }
      public static void main(String[] args) {
          MyThread thread1 = new MyThread();
          MyThread thread2 = new MyThread();
          thread1.start();
          thread2.start();
      }
    }

锁和同步机制

*  在多线程编程中，需要使用锁和同步机制来保证线程安全。
 *  Java 中提供了多种锁和同步机制，包括 synchronized 关键字、ReentrantLock 类、CountDownLatch 类、Semaphore 类等。
 *  synchronized 关键字是 Java 中最常用的同步机制，可以用来保护临界区资源的访问，防止多个线程同时访问造成数据不一致的问题。以下是一个使用 synchronized 实现线程安全的计数器的例子：

public class Counter {
       private int count;
       public synchronized void increment() {
           count++;
      }
       public synchronized int getCount() {
           return count;
      }
    }

ReentrantLock 类是一个可重入锁，它提供了与 synchronized 关键字相似的同步功能，但更加灵活和可控。

以下是一个使用 ReentrantLock 实现线程安全的计数器的例子：

public class Counter {
       private int count;
       private ReentrantLock lock = new ReentrantLock();
    
       public void increment() {
           lock.lock();
           try {
               count++;
          } finally {
               lock.unlock();
          }
      }
    
       public int getCount() {
           lock.lock();
           try {
               return count;
          } finally {
               lock.unlock();
          }
      }
    }

线程池

线程池是多线程编程中的一种常用技术，它可以管理和复用线程，提高程序的性能和可维护性。

Java 中提供了 Executor 框架和 ThreadPoolExecutor 类来实现线程池。以下是一个使用 ThreadPoolExecutor 实现的线程池例子：

public public class ThreadPoolExample {
       public static void main(String[] args) {
           ExecutorService executor = Executors.newFixedThreadPool(2);
           for (int i = 0; i < 10; i++) {
               executor.execute(new WorkerThread("Thread " + i));
          }
           executor.shutdown();
           while (!executor.isTerminated()) {
               // 等待线程池中的任务执行完毕
          }
           System.out.println("All threads have been terminated.");
      }
    }
    
    class WorkerThread implements Runnable {
       private String name;
       public WorkerThread(String name) {
           this.name = name;
      }
    
       @Override
       public void run() {
           System.out.println("Start executing thread " + name);
           try {
               Thread.sleep(1000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
           System.out.println("Finish executing thread " + name);
      }
    }

并发集合

Java 提供了一些并发集合类，例如 ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList 等，用于在多线程环境下安全地读写数据。这些集合类采用了一些特殊的技术，例如分段锁、CAS（Compare And Swap）等，来保证线程安全。

以下是一个使用 ConcurrentHashMap 实现的线程安全的计数器例子：

public class ConcurrentCounter {
       private ConcurrentHashMap<String, Integer> counter = new ConcurrentHashMap<>();
       public void increment(String key) {
           counter.compute(key, (k, v) -> v == null ? 1 : v + 1);
      }
    
       public int getCount(String key) {
           return counter.get(key);
      }
    }

并发编程实践

下面介绍一个简单的并发编程实践：多线程下载器。该下载器使用多个线程同时下载一个文件，从而加快下载速度。

public class MultiThreadDownloader {
       private URL url;
       private int threadCount;
       public MultiThreadDownloader(String urlString, int threadCount) throws MalformedURLException {
           this.url = new URL(urlString);
           this.threadCount = threadCount;
      }
    
       public void download() throws IOException, InterruptedException {
           HttpURLConnection connection = (HttpURLConnection) url.openConnection();
           int fileSize = connection.getContentLength();
           connection.disconnect();
           int blockSize = fileSize / threadCount + 1;
           CountDownLatch latch = new CountDownLatch(threadCount);
           for (int i = 0; i < threadCount; i++) {
               int start = i * blockSize;
               int end = Math.min((i + 1) * blockSize - 1, fileSize - 1);
               new DownloadThread(url, start, end, latch).start();
          }
           latch.await();
           System.out.println("Download completed.");
      }
       public static void main(String[] args) throws IOException, InterruptedException {
           MultiThreadDownloader downloader = new MultiThreadDownloader("https://www.example.com/file.txt", 4);
           downloader.download();
      }
    }
    class DownloadThread extends Thread {
       private URL url;
       private int start;
       private int end;
       private CountDownLatch latch;
    
       public DownloadThread(URL url, int start, int end, CountDownLatch latch) {
           this.url = url;
           this.start = start;
           this.end = end;
           this.latch = latch;
      }
       @Override
       public void run() {
           try {
               HttpURLConnection connection = (HttpURLConnection) url.openConnection();
               connection.setRequestProperty("Range", "bytes=" + start + "-" + end);
               InputStream in = connection.getInputStream();
               FileOutputStream out = new FileOutputStream("file.txt", true);
               byte[] buffer = new byte[4096];
               int len;
               while ((len = in.read(buffer)) != -1) {
                   out.write(buffer, 0, len);
              }
               in.close();
               out.close();
               connection.disconnect();
               System.out.println("Downloaded bytes " + start + "-" + end + ".");
          } catch (IOException e) {
               e.printStackTrace();
          } finally {
               latch.countDown();
          }
      }
    }

*  在主函数中，我们创建了一个 MultiThreadDownloader 对象，指定了下载文件的 URL 和线程数。
 *  download 方法中，首先发送一个 HEAD 请求获取文件大小，然后根据线程数计算出每个线程下载的数据块大小。
 *  接下来，使用 CountDownLatch 来控制所有线程的执行，创建 threadCount 个 DownloadThread 对象，并启动它们。
 *  每个 DownloadThread 对象都指定了下载数据的起始位置和终止位置，以及一个 CountDownLatch 对象。
 *  DownloadThread 的 run 方法中，首先发送一个 GET 请求，指定下载数据的范围，然后将数据写入本地文件，并计数器减一。最后在主函数中等待所有线程执行完毕。

总结

本文简单介绍了 Java 多线程与并发编程的基础知识和常用技术。

在实际开发中，需要根据具体的场景选择合适的并发模型和工具，避免出现死锁、竞态条件等并发问题，从而实现高效、安全的多线程编程。