JAVA多线程基础-低调大师

JAVA多线程基础

2018-01-01 629

一：线程与进程

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 }

运行结果为：

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

微信关注我们

原文链接：https://yq.aliyun.com/articles/643513

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

为什么机器学习难于应用

应用机器学习是有挑战性的。在机器学习领域，你必须要在没有正确答案的问题上做出很多决定！例如： · 用什么框架？ · 用什么数据作为输入，要输出什么数据？ · 用什么算法？ · 用什么算法配置？这些问题对于初学者来说是一个严峻的挑战。读完本文之后，你将了解： · 如何形成一个明确的学习问题。 · 当给你的问题设计一个学习系统的时候，有四个决策点需要考虑。 · 你可以用三个决策来明确地来应对在实践中设计学习系统的难题。概述本文分成了如下六个部分： 1、适定的学习问题 2、选择训练数据 3、选择目标函数 4、选择目标函数的表达形式 5、选择学习算法 6、如何设计学习系统适定的学习问题我们可以将应用机器学习领域中的一般学习任务定义为一个程序，它可以根据特定的性能测量从一些任务中学习经验。 Tom Mitchell在他1997年《Machine Learning

2018-01-02

606

SOTON私人定制：利用Python进行数据分析（学习Numpy）

Numpy:数组和矢量计算包对于大部分数据分析工具，作者主要关注如下功能快速矢量化矩阵运算，用于数据规整化和清理，筛选，过滤，格式转换等常用矩阵算法，排序、唯一值和集合运算高效描述性统计和聚合分析数据对准，和关联数据操作，从而便于合并不同类型的数据集避免使用if-elif-else和loops进行逻辑判断分组数据操作而Numpy的部分功能如下： ndarray, 一个具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组用于对整组数据进行快速运算的标准数学函数（无需编写循环函数）用于读写磁盘数据的工具以及用于操作内存映射文件的工具线性代数，随机数生成以及傅里叶变换功能用于继承由C, C++, Fortran等语言编写的代码的工具尽管Numpy并不满足作者的所有需求，但是熟练掌握的Numpy的面向数组编程(arrary-oriented programming)，以数组的方式思考对成为Python数据分析科学家至关重要。 ndarray: 多维数组对象，高效的源头 Python低效的原因有一个就是“在Python里面一切都是对象”，所以它不存在基本数据类型，...

2018-01-02

618

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。