计算机的线程2

1.创建线程

方法1 继承Thread类

继承Thread类来创建一个线程类。

class MyThread extends Thread {
     @Override
     public void run () {
        System.out.println("这里是线程运行的代码");
     }
}

 创建MyThread类的实例

MyThread t = new MyThread( );

调用start方法启用线程

t.start ( );  //线程开始运行

方法2 实现Runnable 接口

1.实现Runnable接口

class MyRunnable implements Runnable {
    @overrride
    public void run ( ) {
       System.out.println ("这里是线程运行的代码");
    }
}

2.创建Thread 类实例，调用Thread的构造方法时将Runnable对象作为target

参数。

Thread t = new Thread(new MyRunnable( ));

3.调用start方法

t.start( );  // 线程开始运行

对比上面两种方法：

1.继承Thread类，直接使用this就表示当前线程对象的引用。

2.实现Runnable接口，this表示的是MyRunnable的引用。需要使用Thread.currentThread（）。

其他变形

1.匿名内部类创建Thread子类对象

// 使用匿名类创建Thread子类对象
Thread t1 = new Thread ( ) {
    @override
    public void run ( ) {
       System.out.println ("使用匿名类创建 Thread子类对象");
    }
};

2.匿名内部类创建Runnable子类对象

 // 使用匿名类创建 Runnable子类对象
Thread t2 = new Thread(new Runnable( )) {
   @override
   public void run ( ) {
      System.out.println("使用匿名类创建 Runnable 子类对象"）；
   }
}

3.lambda表达式创建Runnable子类对象

2.多线程的优势-增加运行速度

可以观察多线程在一些场合下是可以提高程序的整体运行效率的。

使用System.nanoTime( ) 可以记录当前系统的纳秒级时间戳。

serial 串行的完成一系列的运算。concurrency 使用两个线程并行的完成同样的运算。

public class ThreadAdvantage {
     // 多线程并不⼀定就能提⾼速度，可以观察，count 不同，实际的运⾏效果也是不同的
     private static final long count = 10_0000_0000;

     public static void main(String[] args) throws InterruptedException {
         // 使⽤并发⽅式
         concurrency();
         // 使⽤串⾏⽅式
         serial();
     }

      private static void concurrency() throws InterruptedException {
          long begin = System.nanoTime();
 
          // 利⽤⼀个线程计算 a 的值
           Thread thread = new Thread(new Runnable() {
              @Overrid
              public void run() {
                  int a = 0;
                  for (long i = 0; i < count; i++) {
                       a--;
                  }
             }
       });
       thread.start();
       // 主线程内计算 b 的值
       int b = 0;
       for (long i = 0; i < count; i++) {
        b--;
       }
        // 等待 thread 线程运⾏结束
        thread.join();
 
        // 统计耗时
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 / 1000 / 1000;
         System.out.printf("并发: %f 毫秒%n", ms);
     }

     private static void serial() {
          // 全部在主线程内计算 a、b 的值
          long begin = System.nanoTime();
          int a = 0;
          for (long i = 0; i < count; i++) {
               a--;
          }
          int b = 0; 
          for (long i = 0; i < count; i++) {
                b--;
          }
          long end = System.nanoTime();
          double ms = (end - begin) * 1.0 / 1000 / 1000;
          System.out.printf("串⾏: %f 毫秒%n", ms);
       }
   }

并发：399.651856毫秒

串行：720.616811毫秒