进程 Process
- 进程是指运行中的程序，比如我们使用QQ,就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
- 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程
线程 Thread
- 线程由进程创建的，是进程的一个实体
- 一个进程可以拥有多个线程，如下图
- 单线程：同一个时刻，只允许执行一个线程
- 多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
- 并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说单核cpu实现的多任务就是并发。
- 并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。并发和并行可以同时出现
Program
A program is a sequence of instructions written in a programming language
Process
A process is an instance of a program that is being executed (e.g. tabs in chrome)
Thread
A thread is a unit of execution within a process (e.g. Apache Server)
在java中线程来使用有两种方法。
- 继承Thread类，重写run方法
- 实现Runnable接口，重写run方法
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
//创建Cat对象，可以当做线程使用
Cat cat = new Cat();
/* 开启start0线程的执行方式
(1)
public synchronized void start() {
start0();
}
(2)
//start0() 是本地方法，是JVM调用, 底层是c/c++实现
//真正实现多线程的效果， 是start0(), 而不是 run
private native void start0()
*/
cat.start();//启动线程-> 最终会执行cat的run方法
//cat.run();//run方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
//说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
//这时 主线程和子线程是交替执行..
System.out.println("主线程继续执行" + Thread.currentThread().getName());// 名字 main
for(int i = 0; i < 60; i++) {
System.out.println("主线程 i=" + i);
//让主线程休眠
Thread.sleep(1000);
}
}
}
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的run方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread {
int times = 0;
@Override
public void run() {//重写run方法，写上自己的业务逻辑
while (true) {
//该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
//让该线程休眠1秒 ctrl+alt+t
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times == 80) {
break;//当times 到80, 退出while, 这时线程也就退出..
}
}
}
}
实现Runnable接口，重写run方法
// 自定义类实现Runnable接口
public class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的任务
for (int i = 0; i < 5; i++) {
System.out.println("子线程运行中：" + i + " —— " + Thread.currentThread().getName());
}
}
public static void main(String[] args) {
// 创建Runnable对象
MyRunnable myRunnable = new MyRunnable();
// 用Thread包装Runnable对象
Thread thread = new Thread(myRunnable);
// 启动线程（不是run，而是start）
thread.start();
// 主线程的代码
for (int i = 0; i < 5; i++) {
System.out.println("主线程运行中：" + i + " —— " + Thread.currentThread().getName());
}
}
}守护线程 Daemon Thread
守护线程与用户线程在大部分行为上是相同的，但它们在决定虚拟机何时退出时有显著差异。当所有用户线程结束时，守护线程也会随之结束。这意味着，如果 JVM 中只剩下守护线程，JVM 会自动退出。
public class ThreadMethod03 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
// 如果我们希望当main线程结束后，子线程自动结束
// 只需将子线程设为守护线程即可
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for( int i = 1; i <= 10; i++) { // main线程
System.out.println("宝强在辛苦的工作...");
Thread.sleep(1000);
}
}
}
class MyDaemonThread extends Thread {
public void run() {
for (; ; ) {//无限循环
try {
Thread.sleep(1000);//休眠1000毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");
}
}
}线程的生命周期
-
NEW 尚未启动的线程处于此状态。
-
RUNNABLE 在Java虚拟机中执行的线程处于此状态。
-
BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
-
WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
-
TIMED WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
-
TERMINATED 已退出的线程处于此状态。
public class ThreadState_ {
public static void main(String[] args) throws InterruptedException {
T t = new T();
System.out.println(t.getName() + " state:" + t.getState());
t.start();
while (Thread.State.TERMINATED != t.getState()) {
System.out.println(t.getName() + " state:" + t.getState());
Thread.sleep(500); // 主线程 休眠
}
System.out.println(t.getName() + " state:" + t.getState());
}
}
class T extends Thread {
@Override
public void run() {
while (true) {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+ " print: hi " + i);
try {
Thread.sleep(1000); // sleep 后，进入 TIMED_WAITING状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
}
}线程同步机制
在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性。也可以这里理解:线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作.
同步具体方法-Synchronized
同步代码块
synchronized(对象){ //得到对象的锁,才能操作同步代码
//需要被同步代码;
}
synchronized 还可以放在方法声明中,表示整个方法 为同步方法
public synchronized void m (String name)(
//需要被同步的代码
}
比如设计一个售票程序
public class SellTicket {
public static void main(String[] args) {
SellTicketThread01 sellTicket1 = new SellTicketThread01();
SellTicketThread01 sellTicket2 = new SellTicketThread01();
SellTicketThread01 sellTicket3 = new SellTicketThread01();
sellTicket1.start();
sellTicket2.start();
sellTicket3.start();
}
}
class SellTicketThread01 extends Thread {
private static int ticketNum = 100;
@Override
public void run() {
while (true) {
if(ticketNum <= 0) {
System.out.println("售票结束");
break;
}
// 有票，休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}这个程序会有线程安全问题，可能会出现 窗口 Thread-0 售出一张票剩余票数= -1这种情况
加上 synchronized 关键字 解决
public class SellTicket {
public static void main(String[] args) {
SellTicketThread01 sellTicket1 = new SellTicketThread01();
SellTicketThread01 sellTicket2 = new SellTicketThread01();
SellTicketThread01 sellTicket3 = new SellTicketThread01();
sellTicket1.start();
sellTicket2.start();
sellTicket3.start();
}
}
class SellTicketThread01 extends Thread {
private static int ticketNum = 100;
private boolean loop = true;
@Override
public void run() {
while (loop) {
sellTicket();
}
}
public synchronized void sellTicket(){
if(ticketNum <= 0) {
System.out.println("售票结束");
loop = false;
return;
}
// 有票，休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}原理
Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
同步的局限性：导致程序的执行效率要降低
同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）
同步方法（静态的）的锁为当前类本身。
public synchronized void sellTicket(){} // 这是一个同步方法也可改为同步代码块
public class SellTicket {
public static void main(String[] args) {
SellTicketThread01 sellTicket1 = new SellTicketThread01();
new Thread(sellTicket1).start();
new Thread(sellTicket1).start();
new Thread(sellTicket1).start();
}
}
class SellTicketThread01 implements Runnable {
private static int ticketNum = 100;
private boolean loop = true;
Object object = new Object(); // 创建 object 对象
@Override
public void run() {
while (loop) {
sellTicket();
}
}
public void sellTicket(){
synchronized (this) { // this 也可替换为 object
if(ticketNum <= 0) {
System.out.println("售票结束");
loop = false;
return;
}
// 有票，休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}同步方法（静态的）的锁为当前类本身
public synchronized static void function1(){} // 此方法的锁加在 SellTicketThread01.class如果在静态方法中，怎么实现一个同步代码块
public static void sellTicket(){
synchronized (SellTicketThread01.class) {}
} 同步方法如果没有使用static修饰：默认锁对象为this
如果方法使用static修饰，默认锁对象：当前类.class
下为错误示范：
class SellTicketThread02 extends Thread {
private static int ticketNum = 100;
private boolean loop = true;
@Override
public void run() {
while (loop) {
sellTicket();
}
}
public void sellTicket(){
synchronized (this) {
if(ticketNum <= 0) {
System.out.println("售票结束");
loop = false;
return;
}
// 有票，休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}
SellTicketThread02 sellTicketThread1 = new SellTicketThread02();
SellTicketThread02 sellTicketThread2 = new SellTicketThread02();
SellTicketThread02 sellTicketThread3 = new SellTicketThread02();
sellTicketThread1.start();
sellTicketThread2.start();
sellTicketThread3.start(); // 创建了三个线程对象。每个线程拥有各自独立的 this 实例，所以 synchronized (this) 实际上锁的不是同一把锁，导致线程并没有真正同步。所以让类实现 Runnable 接口 比较合适。
线程死锁
模拟线程死锁
public class DeadLock_ {
public static void main(String[] args) {
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A线程");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B线程");
A.start();
B.start();
}
}
//线程
class DeadLockDemo extends Thread {
static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
static Object o2 = new Object();// 不管创建多少个DeadLockDemo对象，访问的都是同一个o1，o2对象
boolean flag;
public DeadLockDemo(boolean flag) {//构造器
this.flag = flag;
}
@Override
public void run() {
//下面业务逻辑的分析
//1. 如果flag 为 True, 线程A 就会先得到/ 持有 o1 对象锁, 然后尝试去获取 o2 对象锁
//2. 如果线程A 得不到 o2 对象锁，就会Blocked
//3. 如果flag 为 False, 线程B 就会先得到/ 持有 o2 对象锁, 然后尝试去获取 o1 对象锁
//4. 如果线程B 得不到 o1 对象锁，就会Blocked
if (flag) {
synchronized (o1) {//对象互斥锁, 下面就是同步代码
System.out.println(Thread.currentThread().getName() + " 进入1");
synchronized (o2) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入3");
synchronized (o1) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入4");
}
}
}
}
}释放锁 理论
下面操作会释放锁
- 当前线程的同步方法、同步代码块执行结束案例：上厕所，完事出来
- 当前线程在同步代码块、同步方法中遇到break、return。
案例：没有正常的完事，经理叫他修改bug,不得已出来 - 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
案例：没有正常的完事，发现忘带纸，不得已出来 - 当前线程在同步代码块、同步方法中执行了线程对象的wit0方法，当前线程暂停，并释放锁。
案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去
下面操作不会释放锁 - 线程执行同步代码块或同步方法时，程序调用
Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
案例：上厕所，太困了，在坑位上眯了一会 - 线程执行同步代码块时，其他线程调用了该线程的suspend(方法将该线程挂起该线程不会释放锁。
提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用