java通过什么启动线程 java中如何启动一个新的线程

各位老铁们，大家好，今天由我来为大家分享java通过什么启动线程，以及java中如何启动一个新的线程的相关问题知识，希望对大家有所帮助。如果可以帮助到大家，还望关注收藏下本站，您的支持是我们最大的动力，谢谢大家了哈，下面我们开始吧！

java有几种实现线程的方式

java创建线程的方式有三种

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

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

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

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

import java.util.concurrent.*;

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

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

java中如何启动一个新的线程

java开启新线程的三种方法：

方法1：继承Thread类

1）：定义一个继承自Java.lang.Thread类的类A.

2）：覆盖A类Thread类中的run方法。

3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:

A类 a= new A类();

(2)调用线程对象的start方法:

a.start();//启动一个线程

注意：不要调用run方法。如果run方法被称为对象调用方法，则仍然只有一个线程，并且没有启动新线程。

创建启动线程实例：

方法2：实现Runnable接口

1）：定义要在java.lang.Runnable接口中实现的类A.请注意，A类不是线程类。

2）：覆盖A类Runnable接口中的run方法。

3）：我们编写需要在run方法中执行的操作：在run方法中，线程执行。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:

Thread t= new Thread(new A());

(2)调用线程对象的start方法:

t.start();

代码实例：

方法3：直接在函数体使用

扩展资料：

启动新线程的两种方式对比

继承方式:

1):从设计上分析，Java中类是单继承的,如果继承了Thread了,该类就不能再有其他的直接父类了.

2):从操作上分析,继承方式更简单,获取线程名字也简单.(操作上,更简单)

3):从多线程共享同一个资源上分析,继承方式不能做到.

实现方式:

1):从设计上分析，Java中类可以多实现接口,此时该类还可以继承其他类,并且还可以实现其他接口，设计更为合理.

2):从操作上分析,实现方式稍微复杂点,获取线程名字也比较复杂,得使用Thread.currentThread()来获取当前线程的引用.

3):从多线程共享同一个资源上分析,实现方式可以做到(是否共享同一个资源).

补充：实现方式获取线程名字：

String name= Thread.currentThread().getName();

java 多线程是什么

线程定义比较抽象，简单的说就是一个代码执行流。许多执行流可以混合在一起由CPU调度。线程是允许各种任务交互执行的方式。

Java的线程在操作系统的实现模式依系统不同而不同，可能是系统级别的进程或线程，但对于程序员来说并没有影响。

任务交互的一个好处是增加程序响应。如一个界面程序执行一段耗时的数据库查询，使用单独的线程可以让界面依然响应用户的其他输入，而单线程只能等待查询结束再处理。

JVM以及操作系统会优先处理优先级别高的线程，但不代表这些线程一定会先完成。设定优先级只能建议系统更快的处理，而不能强制。

另外，在运行时，并没有按照函数分界，而是按照机器码/汇编码分界。也就是说不保证任何一段代码是被完整而不打断的执行的（除非你已经使用同步手段）。正由于如此，各种线程同步的方法应运而生。

在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 Callable<Integer> myCallable= new MyCallable();//创建MyCallable对象

6 FutureTask<Integer> ft= new FutureTask<Integer>(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 Callable<Integer>{

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 FutureTask<V> implements RunnableFuture<V>{

2

3//....

4

5}

1 public interface RunnableFuture<V> extends Runnable, Future<V>{

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()方法。

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

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

OK，本文到此结束，希望对大家有所帮助。