多线程的创建 四种方式以及使用建议

多线程的创建

方式一、继承于Thread类

步骤

• 1.创建一个继承于 Thread类的子类
• 2.重写 Thread 类阶run()-ー>将此线程放行的操作声明在run()中
• 3.创建 MyThread类的子类的对象
• 4.通过此对象调 start()

代码

//1.创建一个继承于 Thread类的子类
class Thread1 extends Thread{
//2.重写 Thread 类阶run()-ー>将此线程放行的操作声明在run()中
    @Override
    public void run() {
        //代码
    }
}

public class ThreadTest {
    public static void main(String[] args) {
//        3.创建 MyThread类的子类的对象
        Thread1 t1 =new Thread1();
//        4.通过此对象调 start()
        t1.start();
        }
}

方式二、实现 Runnable接口

步骤

• 1.创建一个实现了 Runnable接口的类
• 2.实现类去实现 Runnable中的抽象方法:run()
• 3.创建实现类的对象
• 4.将此对象作为参数传递到 Thread类的的构造器中,创建 Thread类的对象
• 5.通过 Thread 类的对象调用 start()

代码

//1.创建一个实现了 Runnable接口的类
class Thread2 implements Runnable {
//2.实现类去实现 Runnable中的抽象方法:run()
   @Override
   public void run() {
       //代码
   }
}

public class RunnableThread {
   public static void main(String[] args) {
//3.创建实现类的对象
       Thread2 t2 = new Thread2();
//4.将此对象作为参数传递到 Thread类的的构造器中,创建 Thread类的对象
       Thread c1 = new Thread(t2);
//5.通过 Thread 类的对象调用 start():
// start的作用1⃣️启动线程 2⃣️调用当前线程的run()-->调用了 Runnable类型的 target的run()
       c1.start();
   }
}

以上两者的联系与使用技巧

开发中:优先选择:实现Runnable接口的方式
原因:

• 1.实现的方式没有类的单继承的局限性
• 2.实现的方式更适台来处理多个线程有共享数据的情况。

联系: public class Thread implements Runnable
即Thread 也用Runnable 接口实现

相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

方式三、实现 Callable接口

步骤

• 1、创建一个实现Callable的实现类
• 2、实现call方法，将此线程需要执行的操作声明在call（）中
• 3.创建Callable接口实现类的对象
• 4.将此 Callable接口实现类的对象作为传递FutureTask构造器中,创建FutureTask的对象
• 5.将 FutureTask的对象作为参数传递到 Thread 类的构造器中,创建Thread对象,并调用 start()
• 6,获取 Callable中call方法的返回值

代码

//1、创建一个实现Callable的实现类
class Test implements Callable {
   //2、实现call方法，将此线程需要执行的操作声明在call（）中
   @Override
   public Object call() throws Exception {
       //代码，记得return Object
   }

}

public class CallableTest {
   public static void main(String[] args) {
       //3.创建Callable接口实现类的对象
       Test test = new Test();
       //4.将此 Callable接口实现类的对象作为传递FutureTask构造器中,创建 FutureTask的对象
       FutureTask futureTask = new FutureTask(test2);
       //5.将 FutureTask的对象作为参数传递到 Thread 类的构造器中,创建Thread对象,并调用 start()
       new Thread(futureTask).start();
       try {
           //6,获取 Callable中call方法的返回值
           //get()返回值即为 Future Task构造器参数 Callable-实现类重写call()的返回值
           Object sum = futureTask.get();
           System.out.println(sum);
       } catch (InterruptedException e) {
           e.printStackTrace();
       } catch (ExecutionException e) {
           e.printStackTrace();
       }

   }

}

Callable接口方式的特点

• 1.call()可以有返回值的
• 2.call()可以抛出异常,被外面的操作捕获,获取异常的信息
• 3. Callable是支持泛型的

方式四、线程池

步骤

• 1、提供指定线程数量的线程池
• 2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
• 3、关闭连接池

代码

class test4 implements Runnable {
   @Override
   public void run() {
       //代码
   }
}
public class ThreadPool {
   public static void main(String[] args) {
       //1，提供指定线程数量的线程池
       ExecutorService service = Executors.newFixedThreadPool(10);
       //设置线程池的属性
       ThreadPoolExecutor s = (ThreadPoolExecutor)service;
       s.setCorePoolSize(10);
       //2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
       service.execute(new test4());//适用于Runnable
//        service.submit();//适用于Callable
       //3、关闭连接池
       service.shutdown();
   }
}

线程池的特点

• 1.提高相应速度(减少了的创建新线程的时间)
• 2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
• 3.便于线程管理
  • corePoolSize:核心池的大小
  • maximumPool Size:最大线程数
  • keepAliveTime:线程没有任务时最多保持多长时间后会终止