Java并发编程的不同方法

---

在Java中，并发编程是一种允许在单个处理器或多个处理器上同时运行多个任务或进程的技术。它可以提高应用程序的性能和响应速度。但是，它也为Java开发者带来了新的挑战和复杂性，例如同步和死锁。在本文中，我们将探讨一些并发编程的不同方法，例如多线程和执行器。

Java中的并发编程

Java的以下三个组件用于并发编程

• java.lang.Thread 类

• java.lang.Runnable

• java.util.concurrent

多线程

它是Java编程语言的一个特性，允许我们同时执行多个操作。在多线程中，操作被分成多个较小的部分，称为线程。每个线程执行一个独立的任务，而不会影响其他线程的性能。多线程的主要好处是能够最佳地利用资源（例如CPU），并提高分配操作的执行时间。

在Java中创建线程有两种方法

• 通过实现Runnable接口

• 通过扩展Thread类

在下一个示例中，我们将通过扩展Thread类来创建线程

语法

class nameOfThread extends Thread {
   // operations
}

方法

• 创建一个名为“Thrd”的类，并在其中定义一个名为“operation()”的静态方法以及一个参数。

• 现在，在这个方法中，使用一个将运行4次的for循环，并递增给定的参数。此循环的try块将以指定的时间间隔（即1000毫秒）打印输出。

• 接下来，创建三个线程。在这些线程中，将参数传递给“operation()”方法。

• 最后，在main方法中为线程类创建三个对象，并使用内置方法“start()”执行它们。

线程示例

以下示例演示了我们到目前为止关于多线程的讨论。

class Thrd {
   public static void operation(int data) {
      for(int i = 1; i <= 4; i++) {
      System.out.println(data++);
      try {
         // each iteration performed with interval of 1 sec
         Thread.sleep(1000);
         } catch(Exception exp){}
      }
   }
}
class Thrd1 extends Thread { // thread number 1
   public void run() {
      Thrd.operation(1);
   }
}
class Thrd2 extends Thread { // thread number 2
   public void run() {
      Thrd.operation(5);
   }
}
class Thrd3 extends Thread { // thread number 3
   public void run() {
      Thrd.operation(10);
   }
}
public class ThrdExecution {
   public static void main(String args[]) {
      // creating object for thread class
      Thrd1 oprt1 = new Thrd1();
      Thrd2 oprt2 = new Thrd2();
      Thrd3 oprt3 = new Thrd3();
      // Starting the thread operation
      oprt1.start();
      oprt2.start();
      oprt3.start();
   }
}

输出

1
10
5
2
11
6
3
12
7
4
13
8

执行器

它是Java并发API的一个接口，可以启动和控制线程执行。它定义了三个预定义的类，名为ThreadPoolExecutor、ForkJoinPool和ScheduledThreadPoolExecutor。这些类进一步实现Executor和ExecutorService接口来管理线程。

但是，大多数情况下，我们使用静态工厂方法来创建由Executors实用程序类定义的不同类型的执行器服务：

• newCachedThreadPool()

• newFixedThreadPool()

• newScheduledThreadPool()

方法

• 第一步是导入“java.util.concurrent”包以启用Executor的使用。

• 现在，其余代码与第一个示例类似，除了main()方法。

• 在main()方法中，使用“newFixedThreadPool()”定义一个执行器，并使用其实例和内置方法“execute()”启动线程的执行。

执行器示例

以下示例说明了如何使用newFixedThreadPool()和线程。

import java.util.concurrent.*;
class Thrd {
   public static void operation(int data) {
      for(int i = 1; i <= 4; i++) {
         System.out.println(data++);
         try {
            // each iteration performed with interval of 1 sec
            Thread.sleep(1000);
         } catch(Exception exp){}
      }
   }
}
class Thrd1 extends Thread { // thread number 1
   public void run() {
      Thrd.operation(1);
   }
}
class Thrd2 extends Thread { // thread number 2
   public void run() {
      Thrd.operation(5);
   }
}
class Thrd3 extends Thread { // thread number 3
   public void run() {
      Thrd.operation(10);
   }
}
public class ThrdExecution {
   public static void main(String args[]) {
      // creating executer service
      ExecutorService es = Executors.newFixedThreadPool(3);
      // starting execution
      es.execute(new Thrd1());
      es.execute(new Thrd2());
      es.execute(new Thrd3());
   }
}

输出

1
5
10
2
6
11
3
7
12
8
4
13

结论

我们讨论了Java中并发编程的各种方法，例如线程和执行器。根据需要，每种方法都有其自身的优点和缺点。在这里，线程是并发的基本单元。