创建进程

  1. // 方法一: 从Thread派生一个自定义类，然后重写run()方法
  2. public class ThreadDemo{
  3.     public static void main(String[] args) {
  4.         Thread t = new MyThread();
  5.         t.start(); // 启动新进程
  6.     }
  7. }
  9. class MyThread extends Thread {
  10.     @Override
  11.     public void run(){
  12.         System.out.println("start new thread!");
  13.     }
  14. }
  16. // 方式二：创建Thread实例时，传入一个Runnable实例
  17. public class ThreadDemo{
  18.     public static void main(String[] args) {
  19.         Thread t = new Thread(new MyRunnable());
  20.         t.start(); // 启动新进程
  21.     }
  22. }
  24. class MyRunnable implements Runnable {
  25.     @Override
  26.     public void run(){
  27.         System.out.println("start new thread!");
  28.     }
  29. }
  31. // 方式三：用java8引入的lambda语法进一步简写为
  32. public class ThreadDemo{
  33.     public static void main(String[] args) {
  34.         Thread t = new Thread(()->{
  35.             System.out.println("start new thread!");
  36.         });
  37.         t.start();  // 启动新进程
  38.     }
  39. }

线程的状态

java线程的状态有以下几种：

  • New：新创建的线程，尚未执行；
  • Runnable：运行中的线程，正在执行run()方法的Java代码；
  • Blocked：运行中的线程，因为某些操作被阻塞而挂起；
  • Waiting：运行中的线程，因为某些操作在等待中；
  • Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
  • Terminated：线程已终止，因为run()方法执行完毕。

注意：一个线程对象只能调用一次start()方法启动新线程

线程终止的原因有：

  • 线程正常终止：run()方法执行到return语句返回；
  • 线程意外终止：run()方法因为未捕获的异常导致线程终止；
  • 对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用）。
  1. public class ThreadDemo{
  2.     // 需要抛出 InterruptedException错误
  3.     public static void main(String[] args) throws InterruptedException{
  4.         Thread t = new Thread(() -> {
  5.             System.out.println("hello");
  6.         });
  7.         System.out.println("start");
  8.         t.start();
  9.         t.join();  // 等待t进程执行完毕之后，再执行下面的
  10.         System.out.println("end");
  11.     }
  12. }

中断进程

  1. // 中断线程
  2. // 方式二：在其他线程中对目标线程调用interrupt()方法，调用线程对象.interrupt()中断该线程。
  3. public class ThreadDemo{
  4.     public static void main(String[] args) throws InterruptedException{
  5.         Thread t = new MyThread();
  6.         t.start();
  7.         Thread.sleep(1);  // 暂停1毫秒
  8.         t.interrupt();  // 中断t线程
  9.         t.join();     // 等待t线程结束
  10.         System.out.println("end");
  11.     }
  12. }
  14. class MyThread extends Thread{
  15.     public void run(){
  16.         int n = 0;
  17.         while (!isInterrupted()){
  18.             n++;
  19.             System.out.println(n + " hello!");
  20.         }
  21.     }
  22. }
  24. // 方式二：设置标志位，用running标志位来标识线程是否应该继续运行
  25. public class ThreadDemo{
  26.     public static void main(String[] args) throws InterruptedException{
  27.         MyThread t = new MyThread();
  28.         t.start();
  29.         Thread.sleep(1);
  30.         t.running = false;
  31.     }
  32. }
  34. class MyThread extends Thread{
  35.     public volatile boolean running = true;
  36.     public void run(){
  37.         int n = 0;
  38.         while (running) {
  39.             n++;
  40.             System.out.println(n + " hello!");
  41.         }
  42.         System.out.println("end!");
  43.     }
  44. }
  46. /*
  47. volatile关键字的目的是告诉虚拟机：
  48.     每次访问变量时，总是获取主内存的最新值；
  49.     每次修改变量后，立刻回写到主内存。
  50. */

守护线程

  1. // 守护进程就是：主进程结束被守护的进程无论执行没有执行都会结束
  3. t.setDaemon(true);  // 守护进程一定要写在启动进程前面，不然报错
  4. t.start();

线程同步与方法

  1. // 线程同步
  2. // Java程序使用synchronized关键字对一个对象进行加锁
  3. public class ThreadDemo{
  4.     public static void main(String[] args) throws InterruptedException{
  5.         var add = new AddThread();
  6.         var dec = new DecThread();
  7.         add.start();
  8.         dec.start();
  9.         add.join();
  10.         dec.join();
  11.         System.out.println(Counter.count);
  12.     }
  13. }
  15. class Counter{
  16.     public static final Object lock = new Object();
  17.     public static int count = 0;
  18. }
  20. class AddThread extends Thread{
  21.     public void run(){
  22.         for (int i=0;i<10000;i++){
  23.             synchronized (Counter.lock){  // 获取锁
  24.                 Counter.count += 1;
  25.             }  // 释放锁
  26.         }
  27.     }
  28. }
  30. class DecThread extends Thread{
  31.     public void run(){
  32.         for (int i=0;i<10000;i++){
  33.             synchronized (Counter.lock){
  34.                 Counter.count -= 1;
  35.             }
  36.         }
  37.     }
  38. }
  40. // 线程同步方法
  41. public class Counter {
  42.     private int count = 0;
  44.     public void add(int n) {
  45.         synchronized(this) {
  46.             count += n;
  47.         }
  48.     }
  50.     public void dec(int n) {
  51.         synchronized(this) {
  52.             count -= n;
  53.         }
  54.     }
  56.     public int get() {
  57.         return count;
  58.     }
  59. }
  60. /*
  61. 用synchronized修饰方法可以把整个方法变为同步代码块，synchronized方法加锁对象是this,this当前操作对象的实例
  63. 通过合理的设计和数据封装可以让一个类变为“线程安全”
  64. 一个类没有特殊说明，默认不是thread-safe
  65. */

死锁

  1. // java的线程锁是可重入的锁
  2. // 什么是可重入锁？
  3. // JVM允许同一个线程重复获取同一个锁，这种能被同一个线程反复获取的锁，就叫做可重入锁。
  4. // 由于java的线程锁是可重入锁，所以，获取锁的时候，不但要判断是否是第一次获取，还要记录这是第几次获取。没获取一次锁，记录+1，每退出synchronized块，记录-1，减到0的时候，才会真正释放锁。
  6. // 死锁就是：
  7. /*
  8.     线程1：进入add()，获得lockA；
  9.     线程2：进入dec()，获得lockB。
  10. 随后：
  11.     线程1：准备获得lockB，失败，等待中；
  12.     线程2：准备获得lockA，失败，等待中。
  14. 两个线程都无法获取对方的锁，而导致死锁问题
  15. */