线程的创建以及执行

曾经终败给现在 2022-11-17 10:06 70阅读 0赞

## 线程的创建以及执行 ##

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方法就是让线程就绪,一旦获取资源便开始转为执行