java多线程都有几种方式实现

有三种:
    (1)继承Thread类,重写run函数
        创建:
       

[java]   view plain copy
  1. <span style="font-size:12px;">class xx extends Thread{  
  2.           public void run(){  
  3.             Thread.sleep(1000)    //线程休眠1000毫秒,sleep使线程进入Block状态,并释放资源  
  4.         }}</span>  



        开启线程:
        对象.start()    //启动线程,run函数运行
    (2)实现Runnable接口,重写run函数
        开启线程:
   

[java]   view plain copy
  1. <span style="font-size:12px;">    Thread t = new Thread(对象)    //创建线程对象  
  2.         t.start()</span>  



    (3)实现Callable接口,重写call函数

        Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。 

 

        Callable和Runnable有几点不同:

 

        ①Callable规定的方法是call(),而Runnable规定的方法是run(). 
        ②Callable的任务执行后可返回值,而Runnable的任务是不能返回值的
        ③call()方法可抛出异常,而run()方法是不能抛出异常的。 
        ④运行Callable任务可拿到一个Future对象,Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等

        待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果

 

 

Java  Callable 代码示例:

   

[html]   view plain copy
  1. class TaskWithResult implements Callable<String> {  
  2.     private int id;  
  3.   
  4.     public TaskWithResult(int id) {  
  5.         this.id = id;  
  6.     }  
  7.   
  8.     @Override  
  9.     public String call() throws Exception {  
  10.         return "result of TaskWithResult " + id;  
  11.     }  
  12. }  
  13.   
  14. public class CallableTest {  
  15.     public static void main(String[] args) throws InterruptedException,  
  16.             ExecutionException {  
  17.         ExecutorService exec = Executors.newCachedThreadPool();  
  18.         ArrayList<Future<String>> results = new ArrayList<Future<String>>();    //Future 相当于是用来存放Executor执行的结果的一种容器  
  19.         for (int i = 0; i < 10; i++) {  
  20.             results.add(exec.submit(new TaskWithResult(i)));  
  21.         }  
  22.         for (Future<String> fs : results) {  
  23.             if (fs.isDone()) {  
  24.                 System.out.println(fs.get());  
  25.             } else {  
  26.                 System.out.println("Future result is not yet complete");  
  27.             }  
  28.         }  
  29.         exec.shutdown();  
  30.     }  
  31. }  

运行结果:

 

    result of TaskWithResult 0
result of TaskWithResult 1
result of TaskWithResult 2
result of TaskWithResult 3
result of TaskWithResult 4
result of TaskWithResult 5
result of TaskWithResult 6
result of TaskWithResult 7
result of TaskWithResult 8
result of TaskWithResult 9

Java多线程实现方式主要有以下几种: 1. **继承Thread类**:这是最简单的一种方式,通过继承Thread类并重写run()方法,可以实现多线程。但这种方式没有考虑线程同步问题,所以不是最安全的。 ```java class MyThread extends Thread { public void run(){ //线程执行代码 } } MyThread thread = new MyThread(); // 创建线程对象 thread.start(); // 启动线程 ``` 2. **实现Runnable接口**:这种方式比继承Thread更安全,因为Runnable接口没有继承关系,不会破坏封装性。Runnable接口只包含一个run()方法,所以更简洁。 ```java class MyRunnable implements Runnable { public void run(){ //线程执行代码 } } Thread thread = new Thread(new MyRunnable()); // 创建线程对象 thread.start(); // 启动线程 ``` 3. **实现Callable和Future接口**:这种方式适用于需要返回结果的情况。Callable接口比Runnable接口多了一个返回值和异常处理机制。FutureTask类实现了Future接口,可以用来获取异步计算的结果。这种方式适用于需要返回结果的复杂任务。 ```java class MyCallable implements Callable<Integer> { public Integer call() throws Exception { //线程执行代码,并返回结果 } } FutureTask<Integer> future = new FutureTask<>(new MyCallable()); // 创建FutureTask对象 thread.start(); // 启动线程,同时将FutureTask对象放入新创建的线程中执行 Integer result = future.get(); // 获取结果 ``` 4. **使用Executor框架**:Java提供了Executor框架,可以方便地创建和管理线程池。这种方式适用于需要大量线程的情况,可以避免频繁创建和销毁线程带来的性能开销。 以上就是Java多线程的主要实现方式,可以根据具体需求选择合适的方式
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值