Java系列（十四）__多线程

最新推荐文章于 2024-03-25 20:22:10 发布

礼彬fly

最新推荐文章于 2024-03-25 20:22:10 发布

阅读量1k

点赞数

分类专栏： Java 文章标签： Java系列十四__多线程

Java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

1、进程与线程的区别

从操作系统来讲，可以被民用的系统最早是DOS，但是传统的DOS系统有一个特征：电脑出现病毒之后系统会死机，因为传统的DOS系统采用的是单进程的处理方式。而后来到了windows时代，那么采用的是多进程的处理方式，在同一个时间段上会有多个程序并发执行，轮流强占CPU资源。

但是进程的启动和销毁还是很慢的。所以后来人们开始尝试在进程上做进一步的优化，那么就产生了线程的概念，即：线程是在进程基础之上扩充的。线程的启动和销毁将比进程更快，一个进程上是可以划分出多个线程的，而进程消失的话线程一定也会消失，Java是为数不多的支持多线程编程的语言之一。

2、实现多线程

如果要想实现多线程的开发，那么就必须像主类存在那样，也需要一个线程的主体类，但是这个类并不能单独定义，必须让其继承Thread类或者是实现Runnable接口（如果从实际的开发来讲一定是Runnable接口）。

2.1、继承Thread类

线程的主体类只需要通过extends关键字继承Thread类，那么这个类就可以用于线程的控制，当继承了Thread类之中用户还需要覆写Thread类之中的run()方法“public void run()”。

范例：定义线程的主体类

class MyThread extends Thread {

private String name ; // 理解为对象的名字

public MyThread(String name) {

this.name = name ;

}

@Override

public void run() { // 线程的主方法

for (int x = 0 ; x < 10 ; x ++) {

System.out.println(this.name + "，x = " + x);

}

此时每一个MyThread类的对象都是一个线程，那么可以产生多个线程。

但是当线程主体类定义完成后，必须通过对象进行访问，但是调用的并不是类中的run()方法，而是Thread类的start()方法：“public void start()”。调用此方法就相当于调用了run()方法。

范例：启动多线程

public class TestDemo {

public static void main(String[] args) {

MyThread mtA = new MyThread("线程A") ;

MyThread mtB = new MyThread("线程B") ;

MyThread mtC = new MyThread("线程C") ;

mtA.start() ;

mtB.start() ;

mtC.start() ;

}

如果使用的是run()方法实际上只是一个方法的普通调用，将采用顺序的方式执行，而如果调用的是start()方法则表示将启动多线程，多个线程彼此之间并发运行。

疑问：通过简短的分析，应该已经知道多线程的基本运行过程了，但是为什么非要通过start()来调用run()呢？

为了方便理解，打开关于Thread类中start()方法的定义：

public synchronized void start() {

if (threadStatus != 0)

throw new IllegalThreadStateException();

group.add(this);

boolean started = false;

try {

start0();

started = true;

} finally {

try {

if (!started) {

group.threadStartFailed(this);

}

} catch (Throwable ignore) {

}

private native void start0();

本方法会抛出一个“IllegalThreadStateException”异常，但是如果是手工的使用throw抛出异常，应该使用try…catch处理才对。但是此时并没有强制性要求，因为通过观察“IllegalThreadStateException”继承结构：

java.lang.Object

java.lang.Throwable

java.lang.Exception

java.lang.RuntimeException

java.lang.IllegalArgumentException

java.lang.IllegalThreadStateException

因为RuntimeException子类，一般当一个线程被重复启动的时候就会抛出此异常。所以一个线程只能够启动一次。

可以发现在调用start()方法的时候会自动调用start0()方法，而在start0()方法的声明处发现有一个native关键字，那么此关键字表示的是，将通过本地的原始函数进行代码的实现。

线程的操作一定是需要进行CPU资源调度，每个操作系统的资源调度是不一样的，所以此方法实际上会由JVM实现，那么编写的时候只给出了一个抽象方法的名称，而具体的实现将根据不同的操作系统进行覆写，所以才实现可移植性。

所以可以得出结论，当用户执行start()方法的时候意味着将进行操作系统的资源调配，调配之后才会执行run()方法，即：任何时候只要是启动多线程，都一定要使用Thread类之中的start()方法。

2.2、实现Runnable接口

类与类之间的继承并不推荐去使用，但是类实现接口是一个推荐的功能，在Java里面为了解决多线程的单继承局限问题，所以也提供有一个Runnable接口，用户只需要让线程的主体类实现Runnable接口即可。

范例：观察Runnable接口的定义结构

public interface Runnable {

public void run() ;

}

范例：使用Runnable定义线程主体类

class MyThread implements Runnable {

private String name ;

public MyThread(String name) {

this.name = name ;

}

@Override

public void run() { // 线程的主方法

for (int x = 0 ; x < 10 ; x ++) {

System.out.println(this.name + "，x = " + x);

}

通过之前的分析可以得出结论，只要是线程的启动一定要依靠Thread类的start()方法，如果说现在一个类直接继承了Thread类，那么可以继承下start()方法，但是此时实现的是Runnable接口，那么将没有start()可以被继承。那么下面来观察Thread类中构造方法的定义：“public Thread(Runnable target)”。发现可以接收一个Runnable接口子类对象。

范例：启动多线程

public class TestDemo {

public static void main(String[] args) {

MyThread mtA = new MyThread("线程A") ;

MyThread mtB = new MyThread("线程B") ;

MyThread mtC = new MyThread("线程C") ;

new Thread(mtA).start();

new Thread(mtB).start();

new Thread(mtC).start();

}

此时两者的功能是完全相同的，但是很明显，使用Runnable要比使用Thread更加的合理。

2.3、两种实现方式的区别（面试题）

通过一系列的分析之后已经清楚了多线程的两种实现方式，但是这两种方式从结构上讲一定使用的是Runnable，可是除了这一点之外，还有其它的区别吗？

那么首先来观察一下Thread类的定义：

public class Thread extends Object implements Runnable

发现原来Thread类也实现了Runnable接口，于是一件很有意思的事情发生了。

从结构上讲Thread是一个代理类的结构设计，但是又不那么完整。如果是一个纯粹的代理设计模式，那么用户应该调用的是Thread类的run()方法，但是现在调用的却是start()方法（并不是Runnable接口提供的方法），所以在整个操作之中虽然形式是代理结构，但是最终还是有差异的，而这个差异也是由于历史原因造成的。

除了这个基本的联系之外，还有一点不算区别的小区别：使用Runnable接口实现的多线程要比使用Thread类实现的多线程更容易表示出数据共享的概念。

范例：编写一个简单的卖票程序，利用Thread类实现（产生三个线程对象一起卖票）

package cn.mldn.demo;

class MyThread extends Thread {

private int ticket = 5 ; // 假设有5张票

@Override

public void run() { // 线程的主方法

for (int x = 0 ; x < 20 ; x ++) {

if (this.ticket > 0) {

System.out.println("卖票：ticket = " + this.ticket --);

}

public class TestDemo {

public static void main(String[] args) {

new MyThread().start();// 一个线程

new MyThread().start();// 两个线程

new MyThread().start();// 三个线程

}

这个时候发现每一个线程对象都有各自的五张票进行售卖，不符合要求。

范例：利用Runnable接口实现

package cn.mldn.demo;

class MyThread implements Runnable {

private int ticket = 5 ; // 假设有5张票

@Override

public void run() { // 线程的主方法

for (int x = 0 ; x < 20 ; x ++) {

if (this.ticket > 0) {

System.out.println("卖票：ticket = " + this.ticket --);

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread() ;

new Thread(mt).start();// 一个线程

new Thread(mt).start();// 两个线程

new Thread(mt).start();// 三个线程

}

面试题：请解释出多线程两种实现方式的区别？分别编写程序进行说明？

· 多线程的两种实现方式：继承Thread类、实现Runnable接口；

· 如果继承了Thread类，那么会受到单继承局限，而且不方便表示出数据共享的概念，Thread类是Runnable接口的子类；

· 如果实现了Runnable接口，那么将不受到单继承的影响，同时可以方便的表示出数据共享的操作；

· 但是不管使用何种方式，最终一定要通过Thread类的start()方法才可以启动多线程。

3、多线程操作方法

多线程的所有操作方法基本上都在Thread类之中定义的，所以研究方法也就是一个Thread类的翻译，那么下面主要看三组方法。

3.1、线程的命名和取得

在整个多线程的操作之中，名称是最重要的，因为多线程的运行状态是不确定的，那么系统只能够根据名字来判断出是那一个线程，所以在为线程命名的时候不要有重复，更不要修改。

在Thread类里面提供了如下的几个方法进行名称操作：

· 构造方法：public Thread(Runnable target, String name)；

· 设置名字：public final void setName(String name)；

· 取得名字：public final String getName()。

问题是线程的运行状态不确定，所以要想取得线程的名字，只能够取得当前正在执行的线程。那么在这种情况下如果要想取得当前的线程对象，就必须依靠Thread类的方法：public static Thread currentThread()。

范例：取得线程名字

package cn.mldn.demo;

class MyThread implements Runnable {

@Override

public void run() { // 线程的主方法

System.out.println(Thread.currentThread().getName());

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread() ;

new Thread(mt).start();

new Thread(mt,"带名字").start();

}

发现此时如果设置了线程名称，那么就返回设置的数据。如果没有设置线程名字会自动的进行命名，以保证每一个线程一定有一个名字。

范例：观察如下代码

package cn.mldn.demo;

class MyThread implements Runnable {

@Override

public void run() { // 线程的主方法

System.out.println(Thread.currentThread().getName());

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread() ;

new Thread(mt,"自定义线程").start();

mt.run(); // 主方法之中进行方法调用

}

现在发现通过“mt.run()”执行的时候取得的线程名称是main，所以可以得出结论：主方法也是一个线程，而新的问题就出现了，一直在讨论线程，但是线程依附于进程，进程在那里啊？

每当用户使用java命令解释一个类的时候，对操作系统而言，都会默认启动一个java的进程，而主方法只是这进程之中的一个线程而已。

问题：每一个JVM运行时至少启动几个线程呢？

· 至少启动两个线程：主线程、GC垃圾回收线程。

3.2、线程的休眠

线程的休眠指的是让程序暂缓执行，休眠方法：public static void sleep(long millis) throws InterruptedException；

范例：观察休眠

package cn.mldn.demo;

class MyThread implements Runnable {

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 100; x++) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "，x = " + x);

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread();

new Thread(mt, "线程A").start();

new Thread(mt, "线程B").start();

new Thread(mt, "线程C").start();

new Thread(mt, "线程D").start();

new Thread(mt, "线程E").start();

}

由于线程资源的间隔太短，那么可以简单的理解为：多个线程有可能会同时进入到方法执行。

3.3、线程的优先级

从理论上讲线程的优先级越高，越有可能先执行。但是这也只是可能，如果要想进行线程的优先级操作，可以使用如下的两个方法：

· 设置优先级：public final void setPriority(int newPriority)；

· 取得优先级：public final int getPriority()。

对于优先级在Thread类之中定义了三个常量：

· 最高优先级：public static final int MAX_PRIORITY，10；

· 中等优先级：public static final int NORM_PRIORITY，5；

· 最低优先级：public static final int MIN_PRIORITY，1。

范例：观察优先级改变

package cn.mldn.demo;

class MyThread implements Runnable {

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 20; x++) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "，x = " + x);

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread();

Thread t1 = new Thread(mt, "线程A") ;

Thread t2 = new Thread(mt, "线程B") ;

Thread t3 = new Thread(mt, "线程C") ;

t1.setPriority(Thread.MIN_PRIORITY);

t3.setPriority(Thread.MAX_PRIORITY);

t1.start();

t2.start();

t3.start();

}

问题：请问主线程的优先级是多少呢？

public class TestDemo {

public static void main(String[] args) {

System.out.println(Thread.currentThread().getPriority());

}}

主线程只是个中等优先级。

4、线程同步与死锁

4.1、线程的同步

当多个线程访问同一资源的时候一定需要考虑到同步问题，那么下面首先通过一个简单的卖票程序，来观察不同步的情况。

范例：观察问题

package cn.mldn.demo;

class MyThread implements Runnable {

private int ticket = 8; // 一共8张票

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 20; x++) {

if (this.ticket > 0) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ "，ticket = " + this.ticket--);

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread() ;

new Thread(mt,"票贩子A").start();

new Thread(mt,"票贩子B").start();

new Thread(mt,"票贩子C").start();

new Thread(mt,"票贩子D").start();

new Thread(mt,"票贩子E").start();

new Thread(mt,"票贩子F").start();

}

那么在这个时候就发生了不同步的情况，而发生的原因也很简单。对于整个卖票过程实际上是两步完成的：

· 第一步：使用if语句判断是否有票；

· 第二步：进行票数的修改。

但是此时有可能会出现这样一种情况：如果说现在只有最后一张票了，可以满足if条件判断，所以线程可以通过if语句拦截，可是在修改票之前出现了一个延迟操作，那么有可能在这个延迟的过程之中，又出现了其它线程进入到方法之中，由于此时没有修改票数，那么这个线程也可以满足if条件判断，后面的线程依次类推，所以当休眠时间一过，进行票数修改的时候，都将在已有的票数上修改，自然就有可能出现负数。

那么既然已经清楚了问题的产生原因，下面就必须进行问题的解决，问题的解决关键是需要一把锁。如果要想上好责把“锁”，则可以采用两种方式完成：同步代码块、同步方法。

范例：使用同步代码块

同步代码块是使用synchronized关键字定义的代码块，但是在进行同步的时候一定要设置好一个同步对象，所以这个同步对象一般使用当前对象this表示。

package cn.mldn.demo;

class MyThread implements Runnable {

private int ticket = 8; // 一共8张票

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 20; x++) {

synchronized (this) {

if (this.ticket > 0) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ "，ticket = " + this.ticket--);

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread();

new Thread(mt, "票贩子A").start();

new Thread(mt, "票贩子B").start();

new Thread(mt, "票贩子C").start();

new Thread(mt, "票贩子D").start();

new Thread(mt, "票贩子E").start();

new Thread(mt, "票贩子F").start();

}

此时的程序执行速度变得明显缓慢了，因为需要一个个排队进行，就好比你们上网和去银行取钱。一定是上网快。虽然性能变慢了，但是数据的安全性提高了，也就是说异步处理（不加synchronized）和同步处理（使用synchronized）的区别也在于此。

范例：同步方法实现

如果在一个方法的声明上使用了synchronized关键字，则表示此方法是一个同步方法。

package cn.mldn.demo;

class MyThread implements Runnable {

private int ticket = 8; // 一共8张票

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 20; x++) {

this.sale();

}

public synchronized void sale() {

if (this.ticket > 0) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ "，ticket = " + this.ticket--);

}

public class TestDemo {

public static void main(String[] args) {

MyThread mt = new MyThread();

new Thread(mt, "票贩子A").start();

new Thread(mt, "票贩子B").start();

new Thread(mt, "票贩子C").start();

new Thread(mt, "票贩子D").start();

new Thread(mt, "票贩子E").start();

new Thread(mt, "票贩子F").start();

}

同步的核心意义：一个线程要等待另一个线程执行完毕。

4.2、死锁

死锁实际上是在项目运行过程之中产生的一种问题，所以来讲下面的代码只是为大家演示死锁出现的状况，但是代码本身没有任何研究的意义。

所谓的死锁就是指的互相等待的情况，下面编写代码观察。

package cn.mldn.demo;

class JinBo {

public synchronized void tell(XiePengXiang xpx) {

System.out.println("小金子说：给我5000W，放了你儿子，见钱放人！");

xpx.get();

}

public synchronized void get() {

System.out.println("小金子得到钱，放了小刁。");

}

class XiePengXiang {

public synchronized void tell(JinBo j) {

System.out.println("小谢子说：先放了我儿子，给你5000W，见人给钱！");

j.get();

}

public synchronized void get() {

System.out.println("小谢子亏了钱，救了儿子。");

}

public class TestDemo implements Runnable {

private JinBo jin = new JinBo() ;

private XiePengXiang xpx = new XiePengXiang() ;

public static void main(String[] args) {

new TestDemo() ;

}

public TestDemo() {

new Thread(this).start() ;

jin.tell(xpx);

}

@Override

public void run() {

xpx.tell(jin);

}

结论：多个线程访问同一资源的时候一定要考虑到线程的同步，但是同步会影响程序的性能，同时会提升数据的安全性。过多的同步（synchronized）会有可能出现死锁。

5、线程经典操作案例：生产者与消费者

本程序的核心结构如下：首先定义两个类，一个是生产者线程，另外一个消费者线程类，生产者每生产完一个数据之后，消费者要取走这些数据，那么假设现在的数据有两种：

· title = 小动物，content = 草泥马；

· title = 小金子，content = 不是好孩子。

范例：代码基本模型

package cn.mldn.demo;

class Message {

private String title ;

private String content ;

public void setTitle(String title) {

this.title = title;

}

public void setContent(String content) {

this.content = content;

}

public String getContent() {

return content;

}

public String getTitle() {

return title;

}

class Productor implements Runnable {

private Message msg ;

public Productor(Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0; x < 100; x++) {

if (x % 2 == 0) {

this.msg.setTitle("小动物");

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.msg.setContent("草泥马");

} else {

this.msg.setTitle("小金子");

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.msg.setContent("不是好孩子");

}

class Customer implements Runnable {

private Message msg ;

public Customer(Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0 ; x < 100 ; x ++){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(this.msg.getTitle() + "，" + this.msg.getContent());

}

public class TestDemo {

public static void main(String[] args) {

Message msg = new Message() ;

new Thread(new Productor(msg)).start(); ;

new Thread(new Customer(msg)).start(); ;

}

遗憾的是，这个时候出现了两个问题：

· 数据错位；

· 数据重复取出与重复设置。

5.1、解决数据错位问题

要想解决数据的错位，使用同步处理即可，所以代码修改如下。

package cn.mldn.demo;

class Message {

private String title ;

private String content ;

public synchronized void set(String title,String content) {

this.title = title ;

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.content = content ;

}

public synchronized void get() {

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(this.title + "，" + this.content);

}

class Productor implements Runnable {

private Message msg ;

public Productor(Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0; x < 100; x++) {

if (x % 2 == 0) {

this.msg.set("小动物","草泥马");

} else {

this.msg.set("小金子","不是好孩子");

}

class Customer implements Runnable {

private Message msg ;

public Customer(Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0 ; x < 100 ; x ++){

this.msg.get();

}

public class TestDemo {

public static void main(String[] args) {

Message msg = new Message() ;

new Thread(new Productor(msg)).start(); ;

new Thread(new Customer(msg)).start(); ;

}

现在的数据没有任何错乱，但是重复的操作更严重了。

5.2、解决数据重复操作

如果要想解决重复的操作必须加入等待与唤醒机制。而这样的处理机制是由Object类提供的方法支持，在Object类之中有如下的方法可以使用：

· 等待：public final void wait() throws InterruptedException；

· 唤醒第一个：public final void notify()；

· 唤醒全部：public final void notifyAll()，谁的优先级高就先执行。

范例：解决问题

class Message {

private String title ;

private String content ;

private boolean flag = true ;

// flag = true：表示可以生产，但是不能取走

// flag = false：表示可以取走，但是不能生产

public synchronized void set(String title,String content) {

if (this.flag == false) { // 不能生产

try {

super.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

this.title = title ;

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.content = content ;

this.flag = false ;

super.notify();

}

public synchronized void get() {

if (this.flag == true) {

try {

super.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(this.title + "，" + this.content);

this.flag = true ;

super.notify();

}

此部分的代码没有一个绝对的掌握标准，会了总是好的，如果觉得之前的概念已经没问题了，可以好好看看。

面试题：请解释sleep()和wait()的区别？

· sleep()是Thread类定义的方法，在休眠之后可以自动唤醒；

· wait()是Object类定义的方法，等待之后必须使用notify()或notifyAll()手工唤醒。

礼彬fly

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录