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

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

方法1：继承Thread类

1）：定义一个继承自JavalangThread类的类A

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

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

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

(1)创建线程类对象:

A类   a  =  new   A类();

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

astart();//启动一个线程

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

创建启动线程实例：

方法2：实现Runnable接口

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

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

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

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

(1)创建线程类对象:

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

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

tstart();

代码实例：

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

扩展资料：

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

继承方式:

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

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

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

实现方式:

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

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

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

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

String name = ThreadcurrentThread()getName();

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             Systemoutprintln(ThreadcurrentThread()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             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

6             if (i == 30) {

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

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

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

10                 myThread2start();                     // 调用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             Systemoutprintln(ThreadcurrentThread()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             Systemoutprintln(ThreadcurrentThread()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                 thread1start(); // 调用start()方法使得线程进入就绪状态

11                 thread2start();

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             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

6             if (i == 30) {

7                 Runnable myRunnable = new MyRunnable();

8                 Thread thread = new MyThread(myRunnable);

9                 threadstart();

10             }

11         }

12     }

13 }

14

15 class MyRunnable implements Runnable {

16     private int i = 0;

17

18     @Override

19     public void run() {

20         Systemoutprintln("in MyRunnable run");

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

22             Systemoutprintln(ThreadcurrentThread()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         Systemoutprintln("in MyThread run");

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

39             Systemoutprintln(ThreadcurrentThread()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) {

targetrun();

}

}

复制代码

也就是说，当执行到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             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

10             if (i == 30) {

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

12                 threadstart();                      //线程进入到就绪状态

13             }

14         }

15

16         Systemoutprintln("主线程for循环执行完毕");

17      

18         try {

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

20             Systemoutprintln("sum = " + sum);

21         } catch (InterruptedException e) {

22             eprintStackTrace();

23         } catch (ExecutionException e) {

24             eprintStackTrace();

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             Systemoutprintln(ThreadcurrentThread()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会永远最后输出呢？

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

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

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

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

根据线程名称找到线程，在java中是可以实现的，实现步骤是：

1、首先获取Java VM中当前运行的所有线程

以下代码是用数组返回Java VM中当前运行的所有线程

public static Thread[] findAllThreads()

{

    ThreadGroup group = ThreadcurrentThread()getThreadGroup();

    ThreadGroup topGroup = group;

    / 遍历线程组树，获取根线程组 /

    while ( group != null )

    {

        topGroup    = group;

        group        = groupgetParent();

    }

    / 激活的线程数加倍 /

    int estimatedSize = topGroupactiveCount()  2;

    Thread[] slackList = new Thread[estimatedSize];

    / 获取根线程组的所有线程 /

    int actualSize = topGroupenumerate( slackList );

    / copy into a list that is the exact size /

    Thread[] list = new Thread[actualSize];

    Systemarraycopy( slackList, 0, list, 0, actualSize );

    return (list);

}

2、遍历线程，比对名称，找到需要寻找的线程

以下代码可得到线程的名称

String name = threadgetName();

java中线程池的监控可以检测到正在执行的线程数。

通过线程池提供的参数进行监控。线程池里有一些属性在监控线程池的时候可以使用

taskCount：线程池需要执行的任务数量。

completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount。

largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。

getPoolSize:线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不+

getActiveCount：获取活动的线程数。

通过扩展线程池进行监控。通过继承线程池并重写线程池的beforeExecute，afterExecute和terminated方法，我们可以在任务执行前，执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如：

protected

void

beforeExecute(Thread

t,

Runnable

r)

{

}

以上就是关于java中如何启动一个新的线程全部的内容，包括:java中如何启动一个新的线程、在Java 中多线程的实现方法有哪些，如何使用、java 根据线程名字查询一个线程,能实现吗等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！