并发与并行
并发:指的是两个或者多个事件(任务)在同一时间段内发生。
并行:指的是两个或者多个事件(任务)在同一时刻发生(同时发生)。
线程与进程
- 进程:是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间,一个应用程序可以同时运行多个线程;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行程序就是一个进程从创建、运行到消亡的过程。
- 线程:线程是进程中的一个执行单元,负责当前进程中程序的运行,一个程序中至少有一个线程,一个进程可以有多个线程。
简而言之,一个程序运行后至少有一个进程,一个进程可以包含多个线程。
备注:单核处理器的计算机肯定不能并行的处理多个任务的,只能是多个任务
在单个cpu上并发的执行。同理,线程也是一样的,从宏观角度上理解线程是
一种并行运行的,但是从微观上分析并行运行不可能,即需要一个一个线程的
去执行,当系统只有一个cpu的时候,线程会以某种顺序执行多个线程,我们
把这种情况称之为线程调度。
线程调度:
- 分时调度:所有的线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间
- 抢占式调度:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机一个线程 执行,Java使用的就是抢占式调度方式来运行线程程序。
创建线程类
java使用java.lang.Thread
类代表线程,所有的线程对象都必须是Thread类或者Thread类的子类的实例。每个线程的作用是完成一定的任务,实际上就是执行一段程序流,java使用线程执行体来代表这段程序流。
一、通过继承Thread类来创建并启动多线程
- 创建一个Thread类的子类
- 在Thread类的子类当中重写Thread类的run()方法,设置线程任务(开启后需要做什么)
- 创建Thread类的子类对象
- 调用Thread类中的start方法,开启新线程,执行run方法
void start() 使该线程开始执行;Java虚拟机调用该线程的run方法;
结果是两个线程并发运行;
多次启动一个线程是非法的。特别是当前线程已经结束后,不能再重新启动
示例代码:
package thread;
public class Demo01 extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 10; i++) {
System.out.println("run:"+i);
}
}
public static void main(String[] args) {
Demo01 demo01=new Demo01();
demo01.start();
for (int i = 0; i < 9; i++) {
System.out.println("main:"+i);
}
}
}
备注:所有的线程对象都必须是Thread类或者Thread类的子类的实例
Thread类
构造方法:
- public Thread():分配一个新的线程对象
- public Thread(String name):分配一个指定名字的新的线程对象
- public Thread(Runnable target):分配一个带有指定目标新的线程对象
- public Thread(Runnable target,String name):分配一个带有指定目标的新的线程对象并且带有指定名字的。
常用的方法:
- public String getName():获取当前线程的名称
- public void start():让此线程开始执行,java虚拟机会调用此线程的run方法
- public void run():此线程要执行的任务在此方法内定义。
- public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(临时性暂停线程的执行)
- public static Thread currentThread():获取当前正在执行的线程对象的引用。
创建线程方式二
采用java.long,Runnable也是非常常见的一种,只需要重写run方法即可。
步骤如下:
- 定义一个Runnable接口的实现类
- 在实现类中重写Runnable接口当中的run方法,设置线程任务。
- 创建Runnable接口实现类的对象
- 构建Thread类的对象,在构造方法中传递Runnable接口的实现类对象
- 调用Thread类中的start方法,开启新线程执行run方法
通过实现Runnable接口,使得该类有了多线程类的特征,run方法是多线程程序的一个执行目标,所有的多线程代码都写在run()方法中,Thread类实际上也是实现了Runnable接口的类
在启动的多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target)构建线程对象,然后调用Thread类对象的start方法来运行多线程程序。
备注:Runnable对象仅仅作为Thread类对象的target,Runnable实现类里包含了run方法作为线程的执行体。而实际的线程对象依然是Thread类的实例。
Thread类和Runnable接口的区别
如果一个类继承了Thread类,则不适合资源的共享。但是如果实现了Runnable接口的话,则很容易实现资源共享。
实现Runnable接口比继承Thread类的所具有的优势:
- 适合多个相同的程序代码的线程去共享同一个资源
- 可以避免java中单继承的局限性
- 增加了程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程可以实现分离。
- 线程池只能放入实现Runnable或者Callable类的线程,不能直接放入继承Thread的类。
备注:在java中,每次程序运行至少启动两个线程,一个是main线程,一个垃圾收集线程。因为每当使用java命令去执行一个类的时候,实际上都会启动一个JVM,每一个JVM其实都是在操作系统中启动了一个进程。
匿名内部类方式实现多线程程序的创建
使用线程的匿名内部类方式,可以很方便的实现每个线程执行不同的线程任务操作。
示例代码:
public static void main(String[] args) {
// 创建线程对象
//new Thread().start();
new Thread() {
// 重写run方法
@Override
public void run() {
// 循环20次,打印循环的次数
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}.start();
// 线程的接口Runnable
Runnable run = new Runnable() {
// 重写run方法
@Override
public void run() {
// 循环20次,打印循环的次数
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
};
new Thread(run).start();
// 简化接口的方式
new Thread(new Runnable() {
// 重写run方法
@Override
public void run() {
// 循环20次,打印循环的次数
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}).start();
线程安全
如果有多个线程在同时的运行,而这些线程可能同时在运行这段代码。程序每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的值是一样的,就是线程安全的。
线程的同步
当我们使用多线程访问同一资源的时候,且这多个线程中对资源有的写的操作,就容器出现线程安全问题。
要解决多线程并发访问一个资源的安全问题,java中提供了同步机制(synchronized)来解决。
有三种方式实现同步机制:
- 同步代码块
- 同步方法
- 锁机制
同步代码块:synchronized关键字可以用于方法中的某个代码块中,表示只对这个代码块的资源实行互斥访问。
格式:
synchronized(同步锁) {
// 需要同步操作的代码。
}
同步方法:使用synchornized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外面等待,排队。
格式:
public synchornized void method(){
//可能会产生安全问题的代码
}
同步方法代码示例如下:
@Override
public void run() {
System.out.println(RunnableImpl.class);
// com.zhiyou100.thread.demo01.RunnableImpl@15db9742
System.out.println("this ---->" + this);
// 先判断票是否存在
System.out.println();
while(true){
saleTicket();
}
}
/*
* 静态的同步方法
* 锁对象
* 不能是this
* this是创建对象之后产生的,静态方法优先于对象的创建
* 静态同步方法中的锁对象是本类的class属性--->class文件对象(反射)
*/
public static synchronized void saleTicket() {
/*synchronized (RunnableImpl.class) {*/
if (ticket > 0) {
// 提高卖票的体验感 ,让程序睡眠下
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 票存在,卖出第ticket张票
System.out.println(Thread.currentThread().getName() + "---->正在售卖第" + ticket + "张票");
ticket--;
}
/*}*/
}
备注:同步锁是谁?
对于非static方法,同步锁就是this
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)
同步锁:同步锁是一个对象,是一个抽象的概念,可以想象成在对象上标记了一个锁。
- 锁对象可以是任意类型的。Object
- 多个线程对象,要使用同一把锁。
注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到同步锁谁就拥有资格进入代码块中,其他线程只能在外面等待着。(Blocked阻塞状态)