线程的创建以及执行

线程的创建以及执行

java.lang.Thread 继承java,lang.Object 实现Runable接口
线程创建的三种方式:
继承Thread类来创建多线程类,并重写它的run方法,run方法就是线程的执行体,创建线程的实例,并调用start方法来启动多线程

public static void main(String[] args) {
MyThread01 myThread01 = new MyThread01();
myThread01.setName(“锋道知了”);
myThread01.start();
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName()+“嘿嘿”+i);
}
}
public MyThread01() {
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName()+“哈哈”+i);
}
}
实现Runable接口来创建多线程,并重写它的run方法,run方法就是线程的执行体,创建线程的实例,并以该实例作为target来创建Thread线程对象,然后调用Thread对象的start方法来启动多线程.

public static void main(String[] args) {
                   MyThread02 th = new MyThread02();
                   //Runable没有stat方法
                   Thread thread = new Thread(th);
                   thread.setName("面试心态崩了");
                   thread.start();
                   for (int i = 0; i < 50; i++) {
                             System.out.println(Thread.currentThread().getName()+"哈哈"+i);
                   }
          }
          @Override
          public void run() {
                   for (int i = 0; i < 50; i++) {
                             System.out.println(Thread.currentThread().getName()+"哎哎"+i);
                   }
          }

实现Callable接口来创建多线程类,并重写它的call方法.call方法就是线程的执行体,
    a.创建callable对象的实例
    b.把callable对象包装FutureTask,FutureTask额外的作用就是获取线程的返回值.
    c.以FutureTask作为target来创建Thread对象,然后调用Thread对象的Start方法来启动线程.

可以认为:callable接口是Runable的增强版,Runable接口既没有返回值,也不能抛出异常,所以有时候不太方便,callable接口的call方法既有返回值,又能声明抛出异常.

public static void main(String[] args) {
                   //1创建实例
                   MyThread03 myThread03 = new MyThread03();
                   //2创建FutureTask实例
                   FutureTask<Integer> futureTask = new FutureTask<Integer>(myThread03);
                   //创建线程实例  FutureTask是runnable的实现类
                   Thread thread = new Thread(futureTask);
                   thread.setName("futureTask测试");
                   thread.start();
                   for (int i = 0; i < 50; i++) {
                             System.out.println(Thread.currentThread().getName()+"哈哈"+i);
                   }
                   //获取返回值
                   try {
                             int x = futureTask.get();
                             System.out.println(x);
                   } catch (InterruptedException | ExecutionException e) {
                             // TODO Auto-generated catch block
                             e.printStackTrace();
                   }
          }
          Integer call = 0;
          @Override
          public Integer call() throws Exception {
                   
                   for (int i = 0; i < 50; i++) {
                             System.out.println(Thread.currentThread().getName()+"哈哈"+i);
                             call = call +i;
                   }
                   return call;
          }

两种创建多线程的对比
A:继承Thread类创建多线程,现成无法继续继承其它类,在这种方式下,每个线程都对应一个线程的实例,因此不利于数据模型与执行流的分离.
B:实现Runable或者Callable接口,都是实现接口,线程可以继续去继承其他的类,多个线程也可以共享同一个Runable实例,因此更加利与数据模型与执行流的分离.唯一的坏处就是编程略微复杂.

start方法就是让线程就绪,一旦获取资源便开始转为执行