java-多线程-线程创建

线程创建

继承Thread类方式创建

• 创建一个类，该类继承Thread类

• 继承的类需要重写run()方法，同时该继承类的实例需要调用start()方法才能启动新线程，不能直接调用run()方法

• 由于Thread类也实现了Runnable接口，所以该方式的本质也是实现Runnable接口

  class ThreadDemo extends Thread {
  
      public void run() {
          for(int i = 100; i > 0; i--) {;
              System.out.println(Thread.currentThread().getName() + "-->" +i);
          }
      }
  }
  
  public class TestThread {
  
      public static void main(String args[]) {
          ThreadDemo T1 = new ThreadDemo();
          T1.start();
  
          ThreadDemo T2 = new ThreadDemo();
          T2.start();
      }
  }
  

• Thread的方法

  static Thread	currentThread()	      	                        获取当前正在执行的线程引用
  
  
  long	getId()							返回线程的标识符。
  String	getName()					返回线程名称。
  void	setName(String name)			                将此线程的名称更改为等于参数name。
  int	getPriority()						返回线程优先级。
  void	setPriority(int newPriority)	                        更改此线程的优先级。
  Thread.State	getState()				        返回线程的状态。
  
  
  void	interrupt()						中断线程。
  static boolean	interrupted()			        判断线程是否已被中断。
  boolean	isInterrupted()					判断线程是否已被中断。
  boolean	isAlive()					判断线程是否处于活动状态
  
  
  void	setDaemon(boolean on)			                将此线程标记为守护程序线程或用户线程。
  boolean	isDaemon()					判断线程是否是守护程序线程。
  
      
  void	start()							使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
  void	run()							在该方法中编写线程处理逻辑
  static void	yield()						暂停当前正在执行的线程对象，并执行其他线程。
  void	join()							等待该线程死亡。   
  static void	sleep(long millis)			        在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
  

实现Runnable接口创建

• 创建一个类实现Runnable接口，并实现run()方法

• run()方法中可以定义变量、调用方法、创建类实例

• 创建一个Runnable接口实现类对象，将该对象作为Thread构造函数的参数创建一个线程对象，并调用start()函数

  class RunnableDemo implements Runnable {
  
      @Override
      public void run() {
          for (int i = 100; i > 0; i--) {
              System.out.println(Thread.currentThread().getName() + "-->" + i);
          }
      }
  }
  
  public class TestRunnable {
  
      public static void main(String[] args) {
          RunnableDemo r = new RunnableDemo();
          Thread t1 = new Thread(r);
  
          Thread t2 = new Thread(r);
  
          t1.start();
          t2.start();
      }
  }
  

通过 Callable 和 Future 创建线程

• 创建一个Callable接口的实现类，并实现call()方法，该方法有有返回值。

• 创建Callable子类的实例化对象

• 创建FutureTask对象，并将Callable对象传入FutureTask的构造方法中，FutureTask实现了Runnable接口和Future接口

• 实例化Thread对象，并在构造方法中传入FurureTask对象

• 启动线程

• 使用FurureTask对象的get()方法获取线程返回值

  class CallableDemo implements Callable<String> {
      @Override
      public String call() throws Exception {
          return Thread.currentThread().getName() +"--->"+ 999;
      }
  }
  
  public class TestCallable {
  
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          CallableDemo c = new CallableDemo();
  
          FutureTask<String> f1 = new FutureTask<>(c);
          FutureTask<String> f2 = new FutureTask<>(c);
  
          Thread t1 = new Thread(f1);
          Thread t2 = new Thread(f2);
  
          t1.start();
          t2.start();
  
          System.out.println(f1.get());
          System.out.println(f2.get());
  
      }