您的位置:

java多线程高级用法,Java多线程方法

本文目录一览:

java 如何实现多线程

java中多线程的实现方式有两种,一种是继承java.lang.Thread类,另一种是实现java.lang.Runnable接口。下面是两种方式的简单代码。继承Thread类方式:import java.lang.Thread; //用集成Thread类方式实现多线程。 public class Test{ public static void main(String arg[]){ T t1=new T(); T t2=new T(); //更改新线程名称 t1.setName("t1"); t2.setName("t2"); //启动线程 t1.start(); t2.start(); } } class T extends Thread{ //重写run()方法 public void run(){ System.out.println(this.getName()); } }输出结果为:t1t2实现Runnable接口方式:在使用Runnable接口时需要建立一个Thread实例。因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它的子类的实例。import java.lang.*; //用实现Runnable接口的方式实现多线程。 public class Test{ public static void main(String arg[]){ T t1=new T(); T t2=new T(); //一定要实例化Thread对象,将实现Runnable接口的对象作为参数传入。 Thread th1=new Thread(t1,"t1"); Thread th2=new Thread(t2,"t2"); //启动线程 th1.start(); th2.start(); } } class T implements Runnable{ //重写run()方法 public void run(){ System.out.println(Thread.currentThread().getName()); } }输出结果为:t1t2public void run()方法是JAVA中线程的执行体方法,所有线程的操作都是从run方法开始,有点类似于main()方法,即主线程。

java 多线程有几种实现方法

1、继承Thread类实现多线程

继承Thread类的方法尽管被我列为一种多线程实现方式,但Thread本质上也是实现了Runnable接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法,它将启动一个新线程,并执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。例如:

[java] view plain copy

public class MyThread extends Thread {

public void run() {

System.out.println("MyThread.run()");

}

}

在合适的地方启动线程如下:

[java] view plain copy

MyThread myThread1 = new MyThread();

MyThread myThread2 = new MyThread();

myThread1.start();

myThread2.start();

2、实现Runnable接口方式实现多线程

如果自己的类已经extends另一个类,就无法直接extends Thread,此时,必须实现一个Runnable接口,如下:

[java] view plain copy

public class MyThread extends OtherClass implements Runnable {

public void run() {

System.out.println("MyThread.run()");

}

}

为了启动MyThread,需要首先实例化一个Thread,并传入自己的MyThread实例:

[java] view plain copy

MyThread myThread = new MyThread();

Thread thread = new Thread(myThread);

thread.start();

事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:

[java] view plain copy

public void run() {

if (target != null) {

target.run();

}

}

3、使用ExecutorService、Callable、Future实现有返回结果的多线程

ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问 ,这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征,确实很实用,有了这种特征我就不需要再为了得到返回值而大费周折了,而且即便实现了也可能漏洞百出。

可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了,再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子,在JDK1.5下验证过没问题可以直接使用。

java多线程有哪些方法

java创建线程的方式有三种

第一种是继承Thread类 实现方法run() 不可以抛异常 无返回值

第二种是实现Runnable接口 实现方法run() 不可以抛异常 无返回值

第三种是实现CallableT接口,接口中要覆盖的方法是 public T call() 注意:此方法可以抛异常,而前两种不能 而且此方法可以有返回值

第三种如何运行呢 Callable接口在util.concurrent包中,由线程池提交

import java.util.concurrent.*;

ExecutorService e = Executors.newFixedThreadPool(10); 参数表示最多可以运行几个线程

e.submit(); 这个里面参数传 实现Callable接口那个类的对象

在Java 中多线程的实现方法有哪些,如何使用

Java多线程的创建及启动

Java中线程的创建常见有如三种基本形式

1.继承Thread类,重写该类的run()方法。

复制代码

1 class MyThread extends Thread {

2  

3     private int i = 0;

4

5     @Override

6     public void run() {

7         for (i = 0; i 100; i++) {

8             System.out.println(Thread.currentThread().getName() + " " + i);

9         }

10     }

11 }

复制代码

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4         for (int i = 0; i 100; i++) {

5             System.out.println(Thread.currentThread().getName() + " " + i);

6             if (i == 30) {

7                 Thread myThread1 = new MyThread();     // 创建一个新的线程  myThread1  此线程进入新建状态

8                 Thread myThread2 = new MyThread();     // 创建一个新的线程 myThread2 此线程进入新建状态

9                 myThread1.start();                     // 调用start()方法使得线程进入就绪状态

10                 myThread2.start();                     // 调用start()方法使得线程进入就绪状态

11             }

12         }

13     }

14 }

复制代码

如上所示,继承Thread类,通过重写run()方法定义了一个新的线程类MyThread,其中run()方法的方法体代表了线程需要完成的任务,称之为线程执行体。当创建此线程类对象时一个新的线程得以创建,并进入到线程新建状态。通过调用线程对象引用的start()方法,使得该线程进入到就绪状态,此时此线程并不一定会马上得以执行,这取决于CPU调度时机。

2.实现Runnable接口,并重写该接口的run()方法,该run()方法同样是线程执行体,创建Runnable实现类的实例,并以此实例作为Thread类的target来创建Thread对象,该Thread对象才是真正的线程对象。

复制代码

1 class MyRunnable implements Runnable {

2     private int i = 0;

3

4     @Override

5     public void run() {

6         for (i = 0; i 100; i++) {

7             System.out.println(Thread.currentThread().getName() + " " + i);

8         }

9     }

10 }

复制代码

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4         for (int i = 0; i 100; i++) {

5             System.out.println(Thread.currentThread().getName() + " " + i);

6             if (i == 30) {

7                 Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象

8                 Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程

9                 Thread thread2 = new Thread(myRunnable);

10                 thread1.start(); // 调用start()方法使得线程进入就绪状态

11                 thread2.start();

12             }

13         }

14     }

15 }

复制代码

相信以上两种创建新线程的方式大家都很熟悉了,那么Thread和Runnable之间到底是什么关系呢?我们首先来看一下下面这个例子。

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4         for (int i = 0; i 100; i++) {

5             System.out.println(Thread.currentThread().getName() + " " + i);

6             if (i == 30) {

7                 Runnable myRunnable = new MyRunnable();

8                 Thread thread = new MyThread(myRunnable);

9                 thread.start();

10             }

11         }

12     }

13 }

14

15 class MyRunnable implements Runnable {

16     private int i = 0;

17

18     @Override

19     public void run() {

20         System.out.println("in MyRunnable run");

21         for (i = 0; i 100; i++) {

22             System.out.println(Thread.currentThread().getName() + " " + i);

23         }

24     }

25 }

26

27 class MyThread extends Thread {

28

29     private int i = 0;

30  

31     public MyThread(Runnable runnable){

32         super(runnable);

33     }

34

35     @Override

36     public void run() {

37         System.out.println("in MyThread run");

38         for (i = 0; i 100; i++) {

39             System.out.println(Thread.currentThread().getName() + " " + i);

40         }

41     }

42 }

复制代码

同样的,与实现Runnable接口创建线程方式相似,不同的地方在于

1 Thread thread = new MyThread(myRunnable);

那么这种方式可以顺利创建出一个新的线程么?答案是肯定的。至于此时的线程执行体到底是MyRunnable接口中的run()方法还是MyThread类中的run()方法呢?通过输出我们知道线程执行体是MyThread类中的run()方法。其实原因很简单,因为Thread类本身也是实现了Runnable接口,而run()方法最先是在Runnable接口中定义的方法。

1 public interface Runnable {

2  

3     public abstract void run();

4  

5 }

我们看一下Thread类中对Runnable接口中run()方法的实现:

复制代码

@Override

public void run() {

if (target != null) {

target.run();

}

}

复制代码

也就是说,当执行到Thread类中的run()方法时,会首先判断target是否存在,存在则执行target中的run()方法,也就是实现了Runnable接口并重写了run()方法的类中的run()方法。但是上述给到的列子中,由于多态的存在,根本就没有执行到Thread类中的run()方法,而是直接先执行了运行时类型即MyThread类中的run()方法。

3.使用Callable和Future接口创建线程。具体是创建Callable接口的实现类,并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象,且以此FutureTask对象作为Thread对象的target来创建线程。

看着好像有点复杂,直接来看一个例子就清晰了。

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4

5         CallableInteger myCallable = new MyCallable();    // 创建MyCallable对象

6         FutureTaskInteger ft = new FutureTaskInteger(myCallable); //使用FutureTask来包装MyCallable对象

7

8         for (int i = 0; i 100; i++) {

9             System.out.println(Thread.currentThread().getName() + " " + i);

10             if (i == 30) {

11                 Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程

12                 thread.start();                      //线程进入到就绪状态

13             }

14         }

15

16         System.out.println("主线程for循环执行完毕..");

17      

18         try {

19             int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果

20             System.out.println("sum = " + sum);

21         } catch (InterruptedException e) {

22             e.printStackTrace();

23         } catch (ExecutionException e) {

24             e.printStackTrace();

25         }

26

27     }

28 }

29

30

31 class MyCallable implements CallableInteger {

32     private int i = 0;

33

34     // 与run()方法不同的是,call()方法具有返回值

35     @Override

36     public Integer call() {

37         int sum = 0;

38         for (; i 100; i++) {

39             System.out.println(Thread.currentThread().getName() + " " + i);

40             sum += i;

41         }

42         return sum;

43     }

44

45 }

复制代码

首先,我们发现,在实现Callable接口中,此时不再是run()方法了,而是call()方法,此call()方法作为线程执行体,同时还具有返回值!在创建新的线程时,是通过FutureTask来包装MyCallable对象,同时作为了Thread对象的target。那么看下FutureTask类的定义:

1 public class FutureTaskV implements RunnableFutureV {

2  

3     //....

4  

5 }

1 public interface RunnableFutureV extends Runnable, FutureV {

2  

3     void run();

4  

5 }

于是,我们发现FutureTask类实际上是同时实现了Runnable和Future接口,由此才使得其具有Future和Runnable双重特性。通过Runnable特性,可以作为Thread对象的target,而Future特性,使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序,我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕..”则很可能是在子线程循环中间输出。由CPU的线程调度机制,我们知道,“主线程for循环执行完毕..”的输出时机是没有任何问题的,那么为什么sum =4950会永远最后输出呢?

原因在于通过ft.get()方法获取子线程call()方法的返回值时,当子线程此方法还未执行完毕,ft.get()方法会一直阻塞,直到call()方法执行完毕才能取到返回值。

上述主要讲解了三种常见的线程创建方式,对于线程的启动而言,都是调用线程对象的start()方法,需要特别注意的是:不能对同一线程对象两次调用start()方法。

你好,本题已解答,如果满意

请点右下角“采纳答案”。

java中实现多线程的方法有几种以及如何实现多线程

java中实现多线程的方法有两种,1:继承Tread类;2:实现Runable接口

1、

public class MyThread extends Thread{

//重写run()方法

public void run(){

    //多线程要做的事

}

public static void main(String args[]){

    MyThread m1 = new MyThread();

    MyThread m2 = new MyThread();

    m1.start();

    m2.start();

}

}

2、

public class NThread implements Runable{

    //实现run()方法

    public void run(){

    //多线程要做的事

    }

    public static void main(String args[]){

        NThread nt = new NThread();

        new Thread(nt,"nt1_name").start();

        new Thread(nt,"nt2_name").start();

    }

}