黑马程序员——JAVA多线程

最新推荐文章于 2016-01-27 13:23:43 发布

skyHeXin

最新推荐文章于 2016-01-27 13:23:43 发布

阅读量427

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/skyHeXin/article/details/46552089

本文详细介绍了Java多线程的基本概念、实现方式及其安全性问题。包括进程与线程的区别、多线程的实现方法（继承Thread类与实现Runnable接口）、线程的生命周期、线程调度与优先级设置等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

1:多线程
(1)多线程：一个应用程序有多条执行路径
进程：正在执行的应用程序
线程：进程的执行单元，执行路径
单线程：一个应用程序只有一条执行路径
多线程：一个应用程序有多条执行路径

多进程的意义?
提高CPU的使用率
多线程的意义?
提高应用程序的使用率
(2)Java程序的运行原理及JVM的启动是多线程的吗?
A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。
(3)多线程的实现方案
A:继承Thread类
B:实现Runnable接口
(4)线程的调度和优先级问题
A:线程的调度
a:分时调度
b:抢占式调度 (Java采用的是该调度方式)
B:获取和设置线程优先级
a:默认是5
b:范围是1-10
(5)线程的控制(常见方法)
A:休眠线程
B:加入线程
C:礼让线程
D:后台线程
E:终止线程(掌握)
(6)线程的生命周期(参照线程生命周期图解.bmp)
A:新建
B:就绪
C:运行
D:阻塞
E:死亡
(7)电影院卖票程序的实现
A:继承Thread类
B:实现Runnable接口
(8)电影院卖票程序出问题
A:为了更符合真实的场景，加入了休眠100毫秒。
B:卖票问题
a:同票多次
b:负数票
(9)多线程安全问题的原因(也是我们以后判断一个程序是否有线程安全问题的依据)
A:是否有多线程环境
B:是否有共享数据
C:是否有多条语句操作共享数据
(10)同步解决线程安全问题
A:同步代码块
synchronized(对象) {
需要被同步的代码;
}

这里的锁对象可以是任意对象。

B:同步方法
把同步加在方法上。

这里的锁对象是this

C:静态同步方法
把同步加在方法上。

这里的锁对象是当前类的字节码文件对象

多线程程序示例：

class Demo extends Thread{
private String name ;
Demo(String name){
this.name = name;
}
public void run(){
for(int x = 0; x < 10; x++){
System.out.println(name + "...x=" + x + "...ThreadName=" + Thread.currentThread ().getName());
}
}
}
class ThreadDemo{
public static void main(String[] args){
Demo d1 = new Demo("旺财");
Demo d2 = new Demo("xiaoqiang");
d1.start(); //开启线程，调用run方法。
d2.start();
for(int x = 0; x < 20; x++){
System.out.println("x = " + x + "...over..." + Thread.currentThread().getName());
}
}
}

运行结果：

P.S.
1、可以通过Thread的getName方法获取线程的名称，名称格式：Thread-编号（从0开始）。
2、Thread在创建的时候，该Thread就已经命名了。源码如下：

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

1. 定义类实现Runnable接口。
2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。
4. 调用线程对象的start方法开启线程。

实现Runnable接口的好处：
1. 将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
2. 避免了Java单继承的局限性。所以，创建线程的第二种方式较为常用。

示例：

/准备扩展Demo类的功能，让其中的内容可以作为线程的任务执行。
//通过接口的形式完成。
class Demo implements Runnable{
public void run(){
show();
}
public void show(){
for(int x = 0; x < 20; x++){
System.out.println(Thread.currentThread().getName() + "..." + x);
}
}
}
class ThreadDemo{
public static void main(String[] args){
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}

运行结果：

线程安全问题产生的原因

需求：模拟4个线程同时卖100张票。

代码：

class Ticket implements Runnable{
private int num = 100;
public void run(){
while(true ){
if(num > 0){
try{
Thread. sleep(10);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
}
}
}
}
class TicketDemo{
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();
}
}

运行结果：

原因分析：

出现上图安全问题的原因在于Thread-0通过了if判断后，在执行到“num--”语句之前，num此时仍等于1。
CPU切换到Thread-1、Thread-2、Thread-3之后，这些线程依然可以通过if判断，从而执行“num--”的操作，因而出现了0、-1、-2的情况。

线程安全问题产生的原因：

1. 多个线程在操作共享的数据。
2. 操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

线程安全问题的解决方案：

思路：
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算。
必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

在java中，用同步代码块就可以解决这个问题。
同步代码块的格式：
synchronized(对象){
需要被同步的代码;
}

同步的好处：解决了线程的安全问题。
同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
同步的前提：必须有多个线程并使用同一个锁。

修改后代码：

class Ticket implements Runnable{
private int num = 100;
Object obj = new Object();
public void run(){
while(true ){
synchronized(obj ){
if(num > 0){
System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
}
}
}
}
}
class TicketDemo{
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();
}
}

运行结果：

原因分析：
上图显示安全问题已被解决，原因在于Object对象相当于是一把锁，只有抢到锁的线程，才能进入同步代码块向下执行。因此，当num=1时，CPU切换到某个线程后，如上图的Thread-3线程，其他线程将无法通过同步代码块继而进行if判断语句，只有等到Thread-3线程执行完“num--”操作（此后num的值为0），并且跳出同步代码块后，才能抢到锁。其他线程即使抢到锁，然而，此时num值已为0，也就无法通过if语句判断，从而无法再执行“num--”的操作了，也就不会出现0、-1、-2等情况了。