Java多线程编程总结

发布于：2023-01-18 ⋅ 阅读:(599) ⋅ 点赞:(0)

多线程：Java 给多线程编程提供了内置的支持。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

一个线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

线程的优先级

每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。

Java 线程的优先级是一个整数，其取值范围是 1  - 10 。

默认情况下，每一个线程都会分配一个优先级 。具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

创建一个线程

Java 提供了三种创建线程的方法：

  • 通过实现 Runnable 接口；
  • 通过继承 Thread 类本身；
  • 通过 Callable 和 Future 创建线程。

注意：第四种方案，线程池可以实现多线程。

通过实现 Runnable 接口来创建线程

创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。

为了实现 Runnable，一个类只需要执行一个方法调用 run()， run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

public void run()

新线程创建之后，你调用它的 start() 方法它才会运行。

void start();

创建线程并开始让他执行：

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

结果为：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

通过继承Thread来创建线程

创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。

继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

实例：

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

结果为：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread 方法

下表列出了Thread类的一些重要方法：

序号 方法描述
1 public void start()
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
2 public void run()
如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
3 public final void setName(String name)
改变线程名称，使之与参数 name 相同。
4 public final void setPriority(int priority)
 更改线程的优先级。
5 public final void setDaemon(boolean on)
将该线程标记为守护线程或用户线程。
6 public final void join(long millisec)
等待该线程终止的时间最长为 millis 毫秒。
7 public void interrupt()
中断线程。
8 public final boolean isAlive()
测试线程是否处于活动状态。

上述方法是被 Thread 对象调用的，下面表格的方法是 Thread 类的静态方法。

序号 方法描述
1 public static void yield()
暂停当前正在执行的线程对象，并执行其他线程。
2 public static void sleep(long millisec)
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
3 public static boolean holdsLock(Object x)
当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
4 public static Thread currentThread()
返回对当前正在执行的线程对象的引用。
5 public static void dumpStack()
将当前线程的堆栈跟踪打印至标准错误流。

实例

如下的ThreadClassDemo 程序演示了Thread类的一些方法：

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}
public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}
public class ThreadClassDemo {
 
   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();
 
      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      }catch(InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

运行结果如下，每一次运行的结果都不一样：

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

实现 Callable 接口

1、定义一个线程任务类实现Callable接口，声明线程执行的结果类型。
2、重写线程任务类的call()方法，这个方法可以直接返回执行的结果。
3、创建一个Callable的线程任务对象。
4、把Callable的线程任务对象包装成一个未来任务对象。
5、把未来任务对象包装成线程对象。
6、调用线程start()方法，启动线程。
7、获取线程执行结果。
实例：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Test01 {
    public static void main(String[] args) {
        // 3、创建一个Callable的线程任务对象。
        MyCallable myCallable = new MyCallable();
        // 4、把Callable的线程任务对象包装成一个未来任务对象。
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        // 5、把未来任务对象包装成线程对象。
        Thread thread = new Thread(futureTask);
        // 6、调用线程start()方法，启动线程。
        thread.start();
        // 7、获取线程执行结果。如果此时获取结果的任务还未执行完成，会让出CPU，直至任务执行完成才获取结果。
        try {
            String s = futureTask.get();
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
// 1、定义一个线程任务类实现Callable接口，声明线程执行的结果类型。
class MyCallable implements Callable<String> {
    // 2、重写线程任务类的call()方法，这个方法可以直接返回执行的结果。
    @Override
    public String call() throws Exception {
        return "子线程任务执行,线程名称为：" + Thread.currentThread().getName();
    }
}

结果为:

 线程池实现多线程

第一种： 创建线程池对象；创建单个线程的线程池对象

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class One {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //线程执行
        try{
            executorService.execute(()->{
                System.out.println("使用executor方式实现多线程.....");
                //业务代码
                int i = 99 / 3;
                System.out.println("业务代码执行结果：" + i);
            });
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //线程池用完，关闭线程池
            executorService.shutdown();
        }
    }
}

结果：

第二种： 创建固定数量的线程池(指定核心线程数数量)

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Two {
    public static void main(String[] args) {
        ExecutorService executorService2 = Executors.newFixedThreadPool(2);
        //线程执行
        try{
            executorService2.execute(()->{
                System.out.println("使用executor方式实现多线程.....");
                //业务代码
                int i = 99 / 3;
                System.out.println("业务代码执行结果：" + i);
            });
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //线程池用完，关闭线程池
            executorService2.shutdown();
        }
    }
}

结果：

第三种：创建一个按照计划执行的线程池

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
public class Three {
    public static void main(String[] args) {
        ScheduledExecutorService executorService3 = Executors.newScheduledThreadPool(2);
        //线程执行
        try{
            executorService3.execute(()->{
                System.out.println("使用executor方式实现多线程.....");
                //业务代码
                int i = 99 / 3;
                System.out.println("业务代码执行结果：" + i);
            });
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //线程池用完，关闭线程池
            executorService3.shutdown();
        }
    }
}

结果：

第四种：创建一个自动增长的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Four {
    public static void main(String[] args) {
        ExecutorService executorService4 = Executors.newCachedThreadPool();
        //线程执行
        try{
            executorService4.execute(()->{
                System.out.println("使用executor方式实现多线程.....");
                //业务代码
                int i = 99 / 3;
                System.out.println("业务代码执行结果：" + i);
            });
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //线程池用完，关闭线程池
            executorService4.shutdown();
        }
    }
}

结果：

创建线程的三种方式的对比

  • 1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

  • 2. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的几个主要概念

在多线程编程时，你需要了解以下几个概念：

  • 线程同步
  • 线程间通信
  • 线程死锁
  • 线程控制：挂起、停止和恢复

多线程的使用

有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。

通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。

请记住，上下文的切换开销也很重要，如果你创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布