黑马程序员_java基础加强之多线程

最新推荐文章于 2024-06-19 11:00:59 发布

lisha1025

最新推荐文章于 2024-06-19 11:00:59 发布

阅读量795

点赞数

分类专栏： Java基础加强文章标签：黑马程序员多线程死锁

本文链接：https://blog.csdn.net/zhangli_1025/article/details/17270597

版权

Java基础加强专栏收录该内容

3 篇文章 0 订阅

订阅专栏

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

多线程

多线程的概述

进程：是一个正在执行的的程序。每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫做一个控制单元。
线程：进程的一个独立控制单元，线程在控制这进程的执行。一个进程中至少有个一进程。
例子：Java虚拟机启动时会有一个java.exe进程，该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码在main方法中，该线程称之为主线程。
扩展：JVM启动时不止一个线程，还有负责来垃圾回收机制的线程。

创建线程

创建线程的第一种方式：继承Thread类。

步骤：

1.定义类继承Thread
2.复写Thread类中的run方法
目的：将自定义的代码存储在run方法中，让线程运行。
3.调用线程的start方法。该方法两个作用：启动线程，调用run方法。

发现运行结果每一次都不同

因为多个线程都在获取cpu的执行权。cpu执行到谁，谁就运行。

明确一点，在某一个时刻，只能有一个程序在运行，（多核除外）

cpu在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象的把多线程的运行形容为在互相抢夺cpu的执行权。

这就是多线程的一个特征：随机性。谁抢到谁执行，至于执行多长，cpu说了算。

class demo extends thread

{

public voidrun ()

{

for(int x=0;x<60;x++)

system.out.println("demo run---"+x);

}

class ThreadDemo

{

public static void main (string [] args)

{

demo d = new demo(); //创建好一个线程。

d.start();//开启线程并执行该线程的run方法。

//d.run()//仅仅是对象调用方法。而线程创建了，并没有执行。并且这样还是单线程，运行结束后才会执行main。

for(int x=0;x<60;x++)

system.out.println("main"+x);

}
}

创建线程-run和start特点：

为什么要覆盖run方法呢？

由于Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码。

run和start的区别：
run只执行方法，而start启动线程并执行run方法。

创建线程的第二种方式：实现Runnable接口

步骤：

1.定义类实现Runnable接口。

2.覆盖Runnable接口中的run方法。

3.通过Thread类建立线程对象。

4.将Runnable接口子类对象作为实参，传递给Thread类的构造方法。

5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

售票例子：

class Ticket implements Runnable {

//200 张票
private int ticke = 200;
Objiect obj=new Object();

public void run() {
while ( true ) {
synchronized(obj){

if ( ticket > 0)
System. out .println(Thread. currentThread ().getName()+ " " + ticket --);
}

}

public class ThreadDemo {

public static void main(String[] args) {

Ticket t = new Ticket();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

Thread t3 = new Thread(t);

Thread t4 = new Thread(t);

t1.start();

t2.start();

t3.start();

t4.start();

}
}

实现方式和继承方式有什么区别呢？

如果一个类中，部分代码运行多线程，部分代码不需要实现多线程，则该类实现Runnable类，然后在继承其他类。但是如果一个类继承了Thread类，则所有代码都是多线程的。

实现方式的好处：避免单继承的局限性。在定义多线程时，建议使用多线程。

两种方式的区别：

1.继承Thread类：线程代码存放在Thread子类的run方法中。

2.实现Runnable：线程代码存放在接口子类的run方法中。

多线程安全问题

通过分析，以上售票例子发现，打印出 0，-1，-2等错票。多线程的运行出现了安全问题。

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句执行了一部分，还没有执行完，

另一个线程参与进来执行。导致共享数据的错误。

解决方法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

Java对于对线程的安全问题提供了专业的解决方式：同步代码块

同步代码块 ：

synchronized (对象)

{

需要被同步的代码

}

对象如同锁。持有锁的线程可以在同步中进行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
如这部分修改：

public void run() {

while ( true ) {

synchronized ( new Object()) {

if ( ticketNum > 0) {

try {

Thread. sleep (10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System. out .println(Thread. currentThread ().getName()+ " " + ticketNum --);

}

}
}

多线程同步的前提：

1.必须要有两个或者两个以上的线程。

2.必须是多个线程使用同一个锁。必须保证同步中只有一个线程在运行。

好处：解决多线程的安全问题。
弊端：多个线程都需要判断锁，较为消耗资源.

多线程的死锁
死锁： 同步中嵌套同步。每个线程使用一个锁。
下面的例子，一个线程使用this锁，另一个线程使用Object对象的锁。在同步代码块中嵌套同步函数，在同步函数中嵌套同步代码块。
两个线程同时售票。一个线程使用this锁，另一个线程使用Object对象的锁。在同步代码块中嵌套同步函数，在同步函数中嵌套同步代码块。
class Ticket implements Runnable {