java创建多线程代码 java创建多线程的两种方式

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Java多线程编程

作者 natrium 一理解多线程多线程是这样一种机制它允许在程序中并发执行多个指令流每个指令流都称为一个线程彼此间互相独立线程又称为轻量级进程它和进程一样拥有独立的执行控制由操作系统负责调度区别在于线程没有独立的存储空间而是和所属进程中的其它线程共享一个存储空间这使得线程间的通信远较进程简单 多个线程的执行是并发的也就是在逻辑上同时而不管是否是物理上的同时如果系统只有一个CPU 那么真正的同时是不可能的但是由于CPU的速度非常快用户感觉不到其中的区别因此我们也不用关心它只需要设想各个线程是同时执行即可多线程和传统的单线程在程序设计上最大的区别在于由于各个线程的控制流彼此独立使得各个线程之间的代码是乱序执行的由此带来的线程调度同步等问题将在以后探讨二在Java中实现多线程我们不妨设想为了创建一个新的线程我们需要做些什么？很显然我们必须指明这个线程所要执行的代码而这就是在Java中实现多线程我们所需要做的一切！真是神奇！Java是如何做到这一点的？通过类！作为一个完全面向对象的语言 Java提供了类 java lang Thread 来方便多线程编程这个类提供了大量的方法来方便我们控制自己的各个线程我们以后的讨论都将围绕这个类进行 那么如何提供给 Java 我们要线程执行的代码呢？让我们来看一看 Thread 类 Thread 类最重要的方法是 run() 它为Thread 类的方法 start() 所调用提供我们的线程所要执行的代码为了指定我们自己的代码只需要覆盖它！方法一继承 Thread 类覆盖方法 run() 我们在创建的 Thread 类的子类中重写 run() 加入线程所要执行的代码即可下面是一个例子 public class MyThread extends Thread {int count= number;public MyThread(int num) {number = num;System out println( 创建线程 + number);}public void run() {while(true) {System out println( 线程 + number + :计数 + count);if(++count== ) return;}}public static void main(String args[]) {for(int i = ; i 5; i++) new MyThread(i+1).start();}}这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢？我们不妨来探索一种新的方法：我们不创建 Thread 类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 Thread 类的实例，有点类似回调函数。.WINgWIT.但是 Java 没有指针，我们只能传递一个包含这个方法的类的实例。那么如何限制这个类必须包含这一方法呢？当然是使用接口！（虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗？）Java 提供了接口 java.lang.Runnable 来支持这种方法。方法二：实现 Runnable 接口Runnable 接口只有一个方法 run()，我们声明自己的类实现 Runnable 接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持，我们还必须创建 Thread 类的实例，这一点通过 Thread 类的构造函数public Thread(Runnable target);来实现。下面是一个例子：public class MyThread implements Runnable {int count= 1, number;public MyThread(int num) {number = num;System.out.println("创建线程 " + number);}public void run() {while(true) {System.out.println("线程 " + number + ":计数 " + count);if(++count== 6) return;} }public static void main(String args[]) {for(int i = 0; i 5; i++) new Thread(new MyThread(i+1)).start();}}严格地说，创建 Thread 子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 Thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现Runnable 接口的类的 run 方法，对此大家不妨试验一下。使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。综上所述，两种方法各有千秋，大家可以灵活运用。下面让我们一起来研究一下多线程使用中的一些问题。三：线程的四种状态1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。四：线程的优先级 线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。五：线程的同步由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：public synchronized void accessVal(int newVal);synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下： synchronized(syncObject) {//允许访问控制的代码}synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。六：线程的阻塞为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。1. sleep() 方法：sleep() 允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后 lishixinzhi/Article/program/Java/gj/201311/27622

相关问答

Q1: java求代码,创建三个线程,设置线程名,要求每个线程执行2次

原则上一个线程只能执行一次java创建多线程代码，只有创建2个同样java创建多线程代码的线程分别执行一次，达到java创建多线程代码你这个目的java创建多线程代码：

public class Test {

public static void main(String[] args) throws InterruptedException {

exeThread(new myThread("线程1"));

exeThread(new myThread("线程2"));

exeThread(new myThread("线程3"));

}

public static void exeThread(Thread t) {

t.start();

}

class myThread extends Thread {

public myThread(String name) {

super(name);

}

@Override

public void run() {

System.out.println("线程" + this.getName() + "执行了");

}

Q2: Java多线程程序设计初步入门

在Java语言产生前传统的程序设计语言的程序同一时刻只能单任务操作效率非常低例如程序往往在接收数据输入时发生阻塞只有等到程序获得数据后才能继续运行随着Internet的迅猛发展这种状况越来越不能让人们忍受如果网络接收数据阻塞后台程序就处于等待状态而不继续任何操作而这种阻塞是经常会碰到的此时CPU资源被白白的闲置起来如果在后台程序中能够同时处理多个任务该多好啊！应Internet技术而生的Java语言解决了这个问题多线程程序是Java语言的一个很重要的特点在一个Java程序中我们可以同时并行运行多个相对独立的线程例如我们如果创建一个线程来进行数据输入输出而创建另一个线程在后台进行其它的数据处理如果输入输出线程在接收数据时阻塞而处理数据的线程仍然在运行多线程程序设计大大提高了程序执行效率和处理能力

线程的创建

我们知道Java是面向对象的程序语言用Java进行程序设计就是设计和使用类 Java为我们提供了线程类Thread来创建线程创建线程与创建普通的类的对象的操作是一样的而线程就是Thread类或其子类的实例对象下面是一个创建启动一个线程的语句

Thread thread =new Thread(); file://声明一个对象实例即创建一个线程

Thread run(); file://用Thread类中的run()方法启动线程

从这个例子我们可以通过Thread（）构造方法创建一个线程并启动该线程事实上启动线程也就是启动线程的run（）方法而Thread类中的run（）方法没有任何操作语句所以这个线程没有任何操作要使线程实现预定功能必须定义自己的run（）方法 Java中通常有两种方式定义run（）方法

通过定义一个Thread类的子类在该子类中重写run（）方法 Thread子类的实例对象就是一个线程显然该线程有我们自己设计的线程体run（）方法启动线程就启动了子类中重写的run（）方法

通过Runnable接口在该接口中定义run（）方法的接口所谓接口跟类非常类似主要用来实现特殊功能如复杂关系的多重继承功能在此我们定义一个实现Runnable（）接口的类在该类中定义自己的run（）方法然后以该类的实例对象为参数调用Thread类的构造方法来创建一个线程

线程被实际创建后处于待命状态激活（启动）线程就是启动线程的run（）方法这是通过调用线程的start（）方法来实现的

下面一个例子实践了如何通过上述两种方法创建线程并启动它们

// 通过Thread类的子类创建的线程　 class thread extends Thread { file://自定义线程的run()方法　 public void run() { 　 System out println( Thread is running… ); } 　 } 　 file://通过Runnable接口创建的另外一个线程 class thread implements Runnable 　 { file://自定义线程的run()方法 public void run() { 　 System out println( Thread is running… ); } 　 } 　 file://程序的主类　 class Multi_Thread file://声明主类 { 　 plubic static void mail(String args[]) file://声明主方法 { 　 thread threadone=new thread (); file://用Thread类的子类创建线程　 Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程　 threadone start(); threado start(); 方法启动线程 } 　 }

运行该程序就可以看出线程threadone和threado交替占用CPU 处于并行运行状态可以看出启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类) 调用start()方法启动线程的run()方法不同于一般的调用方法调用一般方法时必须等到一般方法执行完毕才能够返回start()方法而启动线程的run()方法后 start()告诉系统该线程准备就绪可以启动run()方法后就返回start()方法执行调用start()方法语句下面的语句这时run()方法可能还在运行这样线程的启动和运行并行进行实现了多任务操作

线程的优先级

对于多线程程序每个线程的重要程度是不尽相同如多个线程在等待获得CPU时间时往往我们需要优先级高的线程优先抢占到CPU时间得以执行又如多个线程交替执行时优先级决定了级别高的线程得到CPU的次数多一些且时间多长一些这样高优先级的线程处理的任务效率就高一些

Java中线程的优先级从低到高以整数 ~ 表示共分为级设置优先级是通过调用线程对象的setPriority()方法如上例中设置优先级的语句为

thread threadone=new thread (); file://用Thread类的子类创建线程

Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程

threadone setPriority( ); file://设置threadone的优先级

threado setPriority( ); file://设置threado的优先级

threadone start(); threado start(); 方法启动线程

这样线程threadone将会优先于线程threado执行并将占有更多的CPU时间该例中优先级设置放在线程启动前也可以在启动后进行设置以满足不同的优先级需求

线程的（同步）控制

一个Java程序的多线程之间可以共享数据当线程以异步方式访问共享数据时有时候是不安全的或者不和逻辑的比如同一时刻一个线程在读取数据另外一个线程在处理数据当处理数据的线程没有等到读取数据的线程读取完毕就去处理数据必然得到错误的处理结果这和我们前面提到的读取数据和处理数据并行多任务并不矛盾这儿指的是处理数据的线程不能处理当前还没有读取结束的数据但是可以处理其它的数据

如果我们采用多线程同步控制机制等到第一个线程读取完数据第二个线程才能处理该数据就会避免错误可见线程同步是多线程编程的一个相当重要的技术

在讲线程的同步控制前我们需要交代如下概念

用Java关键字synchonized同步对共享数据操作的方法

在一个对象中用synchonized声明的方法为同步方法 Java中有一个同步模型监视器负责管理线程对对象中的同步方法的访问它的原理是赋予该对象唯一一把钥匙当多个线程进入对象只有取得该对象钥匙的线程才可以访问同步方法其它线程在该对象中等待直到该线程用wait（）方法放弃这把钥匙其它等待的线程抢占该钥匙抢占到钥匙的线程后才可得以执行而没有取得钥匙的线程仍被阻塞在该对象中等待

file://声明同步的一种方式将方法声明同步

class store　 {public synchonized void store_in(){… }public synchonized void store_out(){　 … }}

利用wait（） notify（）及notifyAll（）方法发送消息实现线程间的相互联系

Java程序中多个线程通过消息来实现互动联系的这几种方法实现了线程间的消息发送例如定义一个对象的synchonized 方法同一时刻只能够有一个线程访问该对象中的同步方法其它线程被阻塞通常可以用notify（）或notifyAll（）方法唤醒其它一个或所有线程而使用wait（）方法来使该线程处于阻塞状态等待其它的线程用notify（）唤醒

一个实际的例子就是生产和销售生产单元将产品生产出来放在仓库中销售单元则从仓库中提走产品在这个过程中销售单元必须在仓库中有产品时才能提货如果仓库中没有产品则销售单元必须等待

程序中假如我们定义一个仓库类store 该类的实例对象就相当于仓库在store类中定义两个成员方法 store_in（）用来模拟产品制造者往仓库中添加产品 strore_out（）方法则用来模拟销售者从仓库中取走产品然后定义两个线程类 customer类其中的run（）方法通过调用仓库类中的store_out（）从仓库中取走产品模拟销售者另外一个线程类producer中的run（）方法通过调用仓库类中的store_in（）方法向仓库添加产品模拟产品制造者在主类中创建并启动线程实现向仓库中添加产品或取走产品

如果仓库类中的store_in（）和store_out（）方法不声明同步这就是个一般的多线程我们知道一个程序中的多线程是交替执行的运行也是无序的这样就可能存在这样的问题

仓库中没有产品了销售者还在不断光顾而且还不停的在取产品这在现实中是不可思义的在程序中就表现为负值如果将仓库类中的stroe_in（）和store_out（）方法声明同步如上例所示就控制了同一时刻只能有一个线程访问仓库对象中的同步方法即一个生产类线程访问被声明为同步的store_in（）方法时其它线程将不能够访问对象中的store_out（）同步方法当然也不能访问store_in（）方法必须等到该线程调用wait（）方法放弃钥匙其它线程才有机会访问同步方法

lishixinzhi/Article/program/Java/gj/201311/27301

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

Java多线程java创建多线程代码的创建及启动

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

1.继承Thread类java创建多线程代码，重写该类的run()方法。

复制代码

1 class MyThread extends Thread {

3 private int i = 0;

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 {

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()方法定义java创建多线程代码了一个新的线程类MyThread，其中run()方法的方法体代表java创建多线程代码了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

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

复制代码

1 class MyRunnable implements Runnable {

2 private int i = 0;

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 {

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之间到底是什么关系呢java创建多线程代码？我们首先来看一下下面这个例子。

复制代码

1 public class ThreadTest {

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 }

15 class MyRunnable implements Runnable {

16 private int i = 0;

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 }

27 class MyThread extends Thread {

29 private int i = 0;

31 public MyThread(Runnable runnable){

32 super(runnable);

33 }

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 {

3 public abstract void run();

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 {

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

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

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

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 }

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

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 }

27 }

28 }

31 class MyCallable implements CallableInteger {

32 private int i = 0;

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 }

45 }

复制代码

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

1 public class FutureTaskV implements RunnableFutureV {

3 //....

5 }

1 public interface RunnableFutureV extends Runnable, FutureV {

3 void run();

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

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

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

Q4: java多线程共同操作同一个队列,怎么实现?

具体代码如下java创建多线程代码：

以下是两个线程：

import java.util.*;

public class Thread_List_Operation {

//假设有这么一个队列

static List list = new LinkedList();

public static void main(String[] args) {

Thread t;

t = new Thread(new T1());

t.start();

t = new Thread(new T2());

t.start();

}

//线程T1,用来给list添加新元素

class T1 implements Runnable{

void getElemt(Object o){

Thread_List_Operation.list.add(o);

System.out.println(Thread.currentThread().getName() + "为队列添加java创建多线程代码了一个元素");

}

@Override

public void run() {

for (int i = 0; i 10; i++) {

getElemt(new Integer(1));

}

//线程T2,用来给list添加新元素

class T2 implements Runnable{

void getElemt(Object o){

Thread_List_Operation.list.add(o);

System.out.println(Thread.currentThread().getName() + "为队列添加java创建多线程代码了一个元素");

}

@Override

public void run() {

for (int i = 0; i 10; i++) {

getElemt(new Integer(1));

}

//结果（乱序）

Thread-0为队列添加java创建多线程代码了一个元素

Thread-1为队列添加了一个元素

Thread-0为队列添加了一个元素

Thread-1为队列添加了一个元素

Thread-0为队列添加了一个元素

关于java创建多线程代码和java创建多线程的两种方式的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

正文

Java多线程编程

相关问答

相关阅读

sqlserver函数print，sqlserver函数怎么执行

jquery循环同步执行，for循环同步执行

js执行时间如何计算，js 时间

js点击后定时执行函数，js立即执行函数

javascript在服务端执行，javascript服务器

windows执行脚本，windows执行脚本文件

go语言动态执行go语言，golang动态执行代码

navicat执行mysql命令，navicat怎么样执行数据库脚本

目录[+]