JAVA多线程基础-阿里云开发者社区

JAVA多线程基础

2018-01-02 867

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 一：线程与进程 1 线程：进程中负责程序执行的执行单元线程本身依靠程序进行运行线程是程序中的顺序控制流，只能使用分配给程序的资源和环境 2 进程：执行中的程序一个进程至少包含一个线程 3 单线程：程序中只存在一个线程，实际上主方法就是一个主线程 4 多线程：在一个程序中运行多个任...

一：线程与进程

1 线程：进程中负责程序执行的执行单元
线程本身依靠程序进行运行
线程是程序中的顺序控制流，只能使用分配给程序的资源和环境

2 进程：执行中的程序
一个进程至少包含一个线程

3 单线程：程序中只存在一个线程，实际上主方法就是一个主线程

4 多线程：在一个程序中运行多个任务
目的是更好地使用CPU资源

二：线程的实现

1：继承Thread类

 1 package Threads;
 2 
 3 public class Thread_one extends Thread{
 4     
 5     @Override
 6     public void run() {
 7         // TODO Auto-generated method stub
 8         System.out.println(Thread.currentThread().getName());
 9     }
10 }

我们继承Thread类，然后重写run（）方法，写入你要执行的操作；

线程了类是创建好了，下面就是使用这个线程类：

1 package Threads;
2 
3 public class Test1 {
4     public static void main(String[] args) {
5         for (int i = 0; i < 10; i++) {
6             new Thread_one().start();
7         }
8     }
9 }

正确的启动线程的方法是start（）方法，而不是使用run（）方法，下面具体说明；

运行的结果：

我们可以发现多次运行结果是不一样的：

下面我们把启动改为run（）试一试；

1 package Threads;
2 
3 public class Test1 {
4     public static void main(String[] args) {
5         for (int i = 0; i < 10; i++) {
6             new Thread_one().run();
7         }
8     }
9 }

多次运行发现结果都是一样的，发现运行的都是main这个主线程，而没有创建新的线程：

　　总结 run（）和start（）的区别：

　　①：首次正确启动一个线程是使用start（）方法；

　　②：run（）方法中只是定义需要执行的任务，如果调用run方法，即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。

　　③：start（）在调用start（）方法后，线程就进入了就绪的状态，其实也就是一个可运行的状态，什么时候运行是根据cpu的调度的，看这个线程是否抢到了cpu的资源，所以说我们执行多个线程多次执行的顺序结果是不一样的；

2:实现Runnable

 1 package Threads;
 2 
 3 public class Thread_two implements Runnable{
 4 
 5     @Override
 6     public void run() {
 7         // TODO Auto-generated method stub
 8         System.out.println(Thread.currentThread().getName());
 9     }
10 
11 }

继承Thread和实现Runnable实现一个线程过程都差不多；

调用启动有些区别：

 1 package Threads;
 2 
 3 public class Test2 {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         for (int i = 0; i < 10; i++) {
 8             new Thread(new Thread_two()).start();
 9         }
10     }
11 }

我们查看Thread源码发现，他需要一个Runnable类型的对象；

我们附给他我们实现Runnable接口的对象

运行发现实现了效果：

总结：

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

1）：可以避免java中的单继承的限制

四：线程的不同状态及转换：

1、新建状态（New）：新创建了一个线程对象。

2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

解析：

新建状态：

只是创建了这个线程对象。

就绪状态：

该状态的线程位于可运行线程池中，变得可运行，等争抢到cpu资源后就才会真正的进入到可运行的状态；

运行状态：就绪状态的线程获取了CPU，执行程序代码。

阻塞状态：

①：wait();

只能用 notify唤醒或者notifyall

②：sleep

定义毫秒数，到时间自动唤醒，继续执行任务；

③：yield

线程的礼让，让正在执行的线程变成可运行状态，然后在重新争抢cpu。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

④：join加入主线程；

让正在运行的主线程停止，然后先运行这个线程。

 1 package Threads;
 2 
 3 public class Test3 {
 4     public static void main(String[] args) {
 5             System.out.println("开始：");
 6             Thread3 t2=new Thread3();
 7             Thread t=new Thread(t2);
 8             t.start();
 9             System.out.println("结束：");
10     }
11 }

这明显不是我们想要的结果：

使用join加入主线程：

 1 package Threads;
 2 
 3 public class Test3 {
 4     public static void main(String[] args) throws InterruptedException {
 5             System.out.println("开始：");
 6             Thread3 t2=new Thread3();
 7             Thread t=new Thread(t2);
 8             t.start();
 9             t.join();
10             System.out.println("结束：");
11     }
12 }

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

总结：

sleep和wait的区别：

1. 所属的层面不同：Thread类的方法：sleep() Object的方法：wait()。

2.wait停止的线程则需要使用notifyall（）和notifi（）唤醒；
3. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
4. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用；
5. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

五：线程常用的方法：

　　sleep(): 强迫一个线程睡眠Ｎ毫秒。
　　isAlive(): 判断一个线程是否存活。
　　join(): 等待线程终止。
　　activeCount(): 程序中活跃的线程数。
　　enumerate(): 枚举程序中的线程。
　　currentThread(): 得到当前线程。
　　isDaemon(): 一个线程是否为守护线程。
　　setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)
　　setName(): 为线程设置一个名称。
　　wait(): 强迫一个线程等待。
　　notify(): 通知一个线程继续运行。
　　setPriority(): 设置一个线程的优先级。

六：线程的同步：

常用的同步方法就是使用synchronized关键字

为什么要使用线程同步，因为当一个资源可能会有多个线程访问的时候，当第一个线程进来之后对资源进行了修改，但是在修改的过程中第二个线程也进来了，那第二个线程取到的数据就不是最新的数据，是个虚假的数据，那么这个线程所执行的操作都没有意义了；

看个小例子：

 1 package Threads;
 2 
 3 public class Thread3 implements Runnable{
 4     private static int a=10;
 5     @Override
 6     public void run() {
 7         // TODO Auto-generated method stub
 8         try {
 9             Tong();
10         } catch (InterruptedException e) {
11             // TODO Auto-generated catch block
12             e.printStackTrace();
13         }
14     }
15     public static  void Tong() throws InterruptedException{
16         for (int i = 0; i < 10; i++) {
17             System.out.println(Thread.currentThread().getName()+"||||"+(--a));
18             Thread.sleep(1000);
19     }
20     }
21 }
22 
23 
24 
25 
26 package Threads;
27 
28 public class Test3 {
29     public static void main(String[] args) throws InterruptedException {
30             System.out.println("开始：");
31             Thread3 t2=new Thread3();
32             Thread t=new Thread(t2);
33             Thread t3=new Thread(t2);
34             t.start();
35             t3.start();
36             t.join();
37             t3.join();
38             System.out.println("结束：");
39     }
40 }

里面的sleep就是模拟让两个线程同时访问一个资源

运行结果为：

我们可以看到是有重复数据的，也就是虚假的数据 thread-0和thread-1同时访问了count：7这个数据；

解决办法就是使用同步方法：

 1 package Threads;
 2 
 3 public class Thread3 implements Runnable{
 4     private static int a=10;
 5     @Override
 6     public void run() {
 7         // TODO Auto-generated method stub
 8         try {
 9             Tong();
10         } catch (InterruptedException e) {
11             // TODO Auto-generated catch block
12             e.printStackTrace();
13         }
14     }
15     public static synchronized void Tong() throws InterruptedException{
16         for (int i = 0; i < 10; i++) {
17             System.out.println(Thread.currentThread().getName()+"||||"+(--a));
18             Thread.sleep(1000);
19     }
20     }
21 }

加上synchronized 关键字

总结：其实同步就是对这个资源对象就行加锁，只能同时有一个线程能操作这个资源，如果有第二个线程要访问，那只有等第一个线程执行结束之后才能进行访问；

七：实现经典多线程例子生产者，消费者：

首先创建商品类

 1 package Threads;
 2 
 3 public class Piao {
 4     private int count=5;
 5     
 6     public synchronized void sheng() throws InterruptedException{
 7         if(count>=10){
 8             System.out.println("商品过多："+count);
 9             wait();
10         }else{
11             System.out.println("商品生产成功："+(++count));
12             notify();
13         }
14     }
15     public synchronized void mai() throws InterruptedException{
16         if(count<=0){
17             System.out.println("商品库存不够："+count);
18             wait();
19         }else{
20             System.out.println("商品卖出成功："+(--count));
21             notify();
22         }
23     }
24 }

在创建生产者和消费者：

 1 package Threads;
 2 
 3 public class Sheng implements Runnable{
 4     private Piao p;
 5     
 6     public Sheng(Piao p) {
 7         super();
 8         this.p = p;
 9     }
10     @Override
11     public void run() {
12         // TODO Auto-generated method stub
13         for (int i = 0; i < 10; i++) {
14             try {
15                 p.sheng();
16             } catch (InterruptedException e) {
17                 // TODO Auto-generated catch block
18                 e.printStackTrace();
19             }
20         }
21     }
22 }
23 
24 
25 
26 
27 package Threads;
28 
29 public class Mai implements Runnable{
30     private Piao p;
31     
32     public Mai(Piao p) {
33         super();
34         this.p = p;
35     }
36     @Override
37     public void run() {
38         // TODO Auto-generated method stub
39         for (int i = 0; i < 10; i++) {
40             try {
41                 p.mai();
42             } catch (InterruptedException e) {
43                 // TODO Auto-generated catch block
44                 e.printStackTrace();
45             }
46         }
47     }
48 }

测试类：

 1 package Threads;
 2 
 3 public class Test4 {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         Piao p=new Piao();
 8         new Thread(new Mai(p)).start();
 9         new Thread(new Sheng(p)).start();
10     }
11 
12 }

运行结果为：

欢迎大家一起说出自己的想法。

JAVA多线程基础

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

JAVA多线程基础

热门文章

最新文章

相关课程

相关电子书

相关实验场景