Javanewthread 新线程的创建及使用

一、引言

Java 是一种并发编程语言，多线程就是 Java 并发编程的一个重要特征。线程是进程中的一个实体，是 CPU 调度和执行的基本单位。

Java 提供了丰富的线程 API，开发者可以利用这些 API 来实现并发执行的程序。新线程的创建即是多线程编程中一个重要的环节，本文就此主题进行讲解。

二、新线程的概念

线程是程序中的一个执行单元，每个线程都有自己的执行路径。

在 Java 中，线程是通过 thread 类来实现的。若要创建一个新线程，可以通过三种方式：

1. 实现 Runnable 接口
2. 继承 Thread 类
3. 使用 Callable 和 Future 接口

三、新线程的创建

1.实现 Runnable 接口

  public class MyThread implements Runnable {
    public void run() {
      System.out.println("MyThread running");
    }
  }
  //创建新线程
  Thread thread = new Thread(new MyThread());
  thread.start();

需要注意的是，实现 Runnable 接口并不会导致类继承 Thread 类，而是将 Runnable 接口实现类的实例作为 target 对象传递给 Thread 类的构造方法中。

2.继承 Thread 类

  public class MyThread extends Thread {
    public void run() {
      System.out.println("MyThread running");
    }
  }
  //创建新线程
  MyThread thread = new MyThread();
  thread.start();

在继承 Thread 类的方式中，需要覆盖 run() 方法，此方法是新线程运行时执行的方法。新线程对象创建后，通过 start() 方法启动线程。

3.使用 Callable 和 Future 接口

  public class MyThread implements Callable {
    public Integer call() throws Exception {
        int i = 0;
        for (;i<10;i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
        return i;
    }
  }
  //创建新线程
  ExecutorService executorService = Executors.newCachedThreadPool();
  Future
    future = executorService.submit(new MyThread());

   
  

Callable 接口是一个泛型接口，类似于 Runnable 接口。但是，Callable 接口可以返回一个结果，而且可以抛出异常。

Future 接口可以用于异步获取执行结果，当提供者线程计算完成后，获取者线程可以通过 Future.get() 获取执行结果。

四、新线程的使用

1.sleep() 方法

sleep() 方法会使当前线程暂停指定的时间。可以实现线程睡眠、调整线程优先级等功能。

  Thread thread = new Thread(new Runnable() {
    public void run() {
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
  });
  //启动新线程
  thread.start();

2.yield() 方法

yield() 方法会使当前线程让出 CPU 占用，但并不是一定能让出 CPU，具体可以参考 Java API。

  Thread thread1 = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            Thread.yield();
        }
    }
  });
  Thread thread2 = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            Thread.yield();
        }
    }
  });
  thread1.start();
  thread2.start();

3.join() 方法

join() 方法会使调用线程等待新线程完成后再继续执行，使用该方法可以实现简单的线程同步。

  Thread thread = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
  });
  //启动新线程
  thread.start();
  //等待新线程完成
  try {
    thread.join();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }

五、总结

本文主要介绍了新线程的创建和使用，包括实现 Runnable 接口、继承 Thread 类以及使用 Callable 和 Future 接口等方式创建新线程，并介绍了 sleep()、yield()、join() 等常用的新线程处理方法。

多线程是 Java 的一个重要特性，但是线程安全也是开发者需要理解和注意的地方。在实际应用中，需要了解多线程编程的基本原理，并采用合适的编程方式来实现多线程处理。