实现线程的三种方式

1.继承Thread方法
第一步 创建一个Thread类的子类
第二步 在Thread的子类中重写run方法,设置线程任务(线程开启要干什么)
第三步 创建Thread类的子类对象
第四步 调用Thread类中的方法start方法,执行run方法

public class MyThread01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
public class demo01Thread {
    public static void main(String[] args) {
     	MyThread01 thread01=new MyThread01();
        thread01.start();
        }
}
运行结果:
Thread-0-->0
Thread-0-->1
Thread-0-->2
Thread-0-->3
Thread-0-->4
Thread-0-->5
Thread-0-->6
Thread-0-->7
Thread-0-->8
Thread-0-->9

2.实现Runnable接口
第一步 创建一个Runnable类的实现类
第二步 在实现类中重写Runnable接口的run方法,设置线程任务(线程开启要干什么)
第三步 创建Runnable接口的实现类对象
第四步 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
第五步 调用Thread类中的start方法,开启新线程执行run方法

//1.创建一个Runable解口的实现类
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

实现类

public class demo02Thread {
    public static void main(String[] args) {
     	RunnableImpl run=new RunnableImpl();
        Thread thread = new Thread(run);
        Thread thread1 = new Thread(run);
        }
}
运行结果:
Thread-0-->0
Thread-1-->0
Thread-0-->1
Thread-1-->1
Thread-0-->2
Thread-1-->2
Thread-0-->3
Thread-1-->3
Thread-0-->4
Thread-1-->4	

3.实现Callable接口和Future创建线程

创建Callable接口的实现类CallableThread,实现call()方法,并且有返回值。Callable接口是一个带泛型的接口,泛型的类型就是线程返回值的类型。实现Callable接口中的call()方法,方法的返回类型与泛型的类型相同。


public class Main {

  public static void main(String[] args){

   MyThread3 th=new MyThread3();

   //使用Lambda表达式创建Callable对象

     //使用FutureTask类来包装Callable对象

   FutureTask<Integer> future=new FutureTask<Integer>(

    (Callable<Integer>)()->{

      return 5;

    }

    );

   new Thread(task,"有返回值的线程").start();//实质上还是以Callable对象来创建并启动线程

    try{

    System.out.println("子线程的返回值:"+future.get());//get()方法会阻塞,直到子线程执行结束才返回

    }catch(Exception e){

    ex.printStackTrace();

   }

  }

}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. 继承ThreadJava提供了Thread类,我们可以通过继承Thread类来实现多线程。具体步骤如下: (1)创建一个继承Thread类的子类,并重写run()方法。 (2)在子类中创建一个Thread类的实例对象,并调用start()方法启动线程。 示例代码如下: ``` public class MyThread extends Thread { @Override public void run() { // 线程执行的代码 } } // 创建线程并启动 MyThread myThread = new MyThread(); myThread.start(); ``` 2. 实现Runnable接口 Java中还可以通过实现Runnable接口来实现多线程。具体步骤如下: (1)创建一个实现Runnable接口的类,并实现run()方法。 (2)在类中创建一个Thread类的实例对象,将实现了Runnable接口的类的实例对象作为参数传入Thread的构造方法中。 (3)调用Thread实例对象的start()方法启动线程。 示例代码如下: ``` public class MyRunnable implements Runnable { @Override public void run() { // 线程执行的代码 } } // 创建线程并启动 MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start(); ``` 3. 实现Callable接口 Java中还可以通过实现Callable接口来实现多线程。与实现Runnable接口相比,实现Callable接口可以有返回值,并且可以抛出异常。具体步骤如下: (1)创建一个实现Callable接口的类,并实现call()方法。 (2)创建一个ExecutorService线程池对象,调用submit()方法提交Callable类的实例对象。 (3)调用Future类的get()方法获取线程执行结果。 示例代码如下: ``` public class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { // 线程执行的代码 return 1; } } // 创建线程池对象 ExecutorService executorService = Executors.newFixedThreadPool(1); // 提交Callable实例对象 MyCallable myCallable = new MyCallable(); Future<Integer> future = executorService.submit(myCallable); // 获取线程执行结果 int result = future.get(); ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值