您的位置:

java多线程小节(java多线程经典案例)

本文目录一览:

在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的多线程?

一、 什么是多线程:

我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统),多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。

多进程:每个程序都是一个进程,在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源,每开一个进程系统要为该进程分配相关的系统资源(内存资源)

多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情,在进程中的所有线程共享该进程的资源;

主线程:在进程中至少存在一个主线程,其他子线程都由主线程开启,主线程不一定在其他线程结束后结束,有可能在其他线程结束前结束。Java中的主线程是main线程,是Java的main函数;

二、 Java中实现多线程的方式:

继承Thread类来实现多线程:

当我们自定义的类继承Thread类后,该类就为一个线程类,该类为一个独立的执行单元,线程代码必须编写在run()方法中,run方法是由Thread类定义,我们自己写的线程类必须重写run方法。

run方法中定义的代码为线程代码,但run方法不能直接调用,如果直接调用并没有开启新的线程而是将run方法交给调用的线程执行

要开启新的线程需要调用Thread类的start()方法,该方法自动开启一个新的线程并自动执行run方法中的内容

结果:

java多线程的启动顺序不一定是线程执行的顺序,各个线程之间是抢占CPU资源执行的,所有有可能出现与启动顺序不一致的情况。

CPU的调用策略:

如何使用CPU资源是由操作系统来决定的,但操作系统只能决定CPU的使用策略不能控制实际获得CPU执行权的程序。

线程执行有两种方式:

1.抢占式:

目前PC机中使用最多的一种方式,线程抢占CPU的执行权,当一个线程抢到CPU的资源后并不是一直执行到此线程执行结束,而是执行一个时间片后让出CPU资源,此时同其他线程再次抢占CPU资源获得执行权。

2.轮循式;

每个线程执行固定的时间片后让出CPU资源,以此循环执行每个线程执行相同的时间片后让出CPU资源交给下一个线程执行。

希望对您有所帮助!~

如何用Java编写多线程

在java中要想实现多线程,有两种手段,一种是继续Thread类,另外一种是实现Runable接口。

对于直接继承Thread的类来说,代码大致框架是:

?

123456789101112 class 类名 extends Thread{ 方法1; 方法2; … public void run(){ // other code… } 属性1; 属性2; … }

先看一个简单的例子:

?

12345678910111213141516171819202122232425262728 /** * @author Rollen-Holt 继承Thread类,直接调用run方法 * */class hello extends Thread { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i 5; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.run(); h2.run(); } private String name; }

【运行结果】:

A运行 0

A运行 1

A运行 2

A运行 3

A运行 4

B运行 0

B运行 1

B运行 2

B运行 3

B运行 4

我们会发现这些都是顺序执行的,说明我们的调用方法不对,应该调用的是start()方法。

当我们把上面的主函数修改为如下所示的时候:

?

123456 public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.start(); h2.start(); }

然后运行程序,输出的可能的结果如下:

A运行 0

B运行 0

B运行 1

B运行 2

B运行 3

B运行 4

A运行 1

A运行 2

A运行 3

A运行 4

因为需要用到CPU的资源,所以每次的运行结果基本是都不一样的,呵呵。

注意:虽然我们在这里调用的是start()方法,但是实际上调用的还是run()方法的主体。

那么:为什么我们不能直接调用run()方法呢?

我的理解是:线程的运行需要本地操作系统的支持。

如果你查看start的源代码的时候,会发现:

?

1234567891011121314151617 public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. * * A zero status value corresponds to state "NEW". */ if (threadStatus != 0 || this != me) throw new IllegalThreadStateException(); group.add(this); start0(); if (stopBeforeStart) { stop0(throwableFromStop); } } private native void start0();

注意我用红色加粗的那一条语句,说明此处调用的是start0()。并且这个这个方法用了native关键字,次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。

但是start方法重复调用的话,会出现java.lang.IllegalThreadStateException异常。

通过实现Runnable接口:

大致框架是:

?

123456789101112 class 类名 implements Runnable{ 方法1; 方法2; … public void run(){ // other code… } 属性1; 属性2; … }

来先看一个小例子吧:

?

123456789101112131415161718192021222324252627282930 /** * @author Rollen-Holt 实现Runnable接口 * */class hello implements Runnable { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i 5; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1=new hello("线程A"); Thread demo= new Thread(h1); hello h2=new hello("线程B"); Thread demo1=new Thread(h2); demo.start(); demo1.start(); } private String name; }

【可能的运行结果】:

线程A运行 0

线程B运行 0

线程B运行 1

线程B运行 2

线程B运行 3

线程B运行 4

线程A运行 1

线程A运行 2

线程A运行 3

线程A运行 4

关于选择继承Thread还是实现Runnable接口?

其实Thread也是实现Runnable接口的:

?

12345678 class Thread implements Runnable { //… public void run() { if (target != null) { target.run(); } } }

其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有,Thread和Runnable都实现了run方法,这种操作模式其实就是代理模式。关于代理模式,我曾经写过一个小例子呵呵,大家有兴趣的话可以看一下:

Thread和Runnable的区别:

如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。

?

1234567891011121314151617181920212223 /** * @author Rollen-Holt 继承Thread类,不能资源共享 * */class hello extends Thread { public void run() { for (int i = 0; i 7; i++) { if (count 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello h1 = new hello(); hello h2 = new hello(); hello h3 = new hello(); h1.start(); h2.start(); h3.start(); } private int count = 5; }

【运行结果】:

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

大家可以想象,如果这个是一个买票系统的话,如果count表示的是车票的数量的话,说明并没有实现资源的共享。

我们换为Runnable接口:

?

12345678910111213141516171819 /** * @author Rollen-Holt 继承Thread类,不能资源共享 * */class hello implements Runnable { public void run() { for (int i = 0; i 7; i++) { if (count 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello he=new hello(); new Thread(he).start(); } private int count = 5; }

【运行结果】:

count= 5

count= 4

count= 3

count= 2

count= 1

总结一下吧:

实现Runnable接口比继承Thread类所具有的优势:

1):适合多个相同的程序代码的线程去处理同一个资源

2):可以避免java中的单继承的限制

3):增加程序的健壮性,代码可以被多个线程共享,代码和数据独立。

所以,本人建议大家劲量实现接口。

?

java 多线程是什么?

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

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

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

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

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