根据b站韩顺平教育韩顺平教育java教学视频学习的学习笔记。个人学习理解，如有疏漏，敬请改正。
程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合（即我们编写的代码）
进程：
OS(操作系统)定义：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位
进程实体（进程映像）：由程序段、相关的数据段和PCB（进程控制块）三部分构成
1、进程是指运行中的程序（app）
2、进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它的自身的产生、存在和消亡的过程
线程(Threads)
OS定义：线程是一个基本的CPU执行单元，也是程序执行流的最小单位。线程是为了减少程序并发执行时的开销引入的。（详情请自行查阅操作系统）
1、线程由进程创建的，是进程的一个实体
2、一个进程可以拥有多个线程
单线程：同一个时刻，只允许执行一个线程
多线程：同一个时刻，可以执行多个线程
并发：
OS定义：指两个或多个事件在同一时间间隔内发生。这些事件宏观上是同时发生的，但微观上是交替执行的
同一个时刻，多个任务交替执行，造成一种“同时 ”的错觉，单核CPU实现的多任务就是并发
并行：
OS定义：指两个或多个事件在同一时刻同时发生
同一个时刻，多个任务同时执行，多核CPU可以实现并行
线程创建
创建线程的两种方式
1、继承Thread类，重写run方法
2、实现Runnable接口，重写run方法
继承Thread类创建线程
在终端（Terminal）输入JConsole可以监控线程执行情况
当主线程结束以后，子线程可以继续执行，只有当所有线程都结束以后，整个进程才会结束。main只是开启进程的入口，子线程也可以开启一个子线程。
package com.zdz.annotation;
/**
* @version null
* @anthor zdz/Maddox
*/
public class Thread_ {
//演示通过继承Thread类创建线程
public static void main(String[] args) {
//创建一个QQ对象，可以当做线程使用
QQRun qqRun = new QQRun();
//qqRun.run();//并不是启动一个线程而是调用一个普通方法，没有真正启动一个线程，就会是串行化执行
/*
1、public synchronized void start() {
start0();
}
2、private native void start0();
start0()是一个本地方法，由JVM调用，底层是c/c++实现
真正实现多线程的效果是 start0()方法
*/
qqRun.start();//启动线程，最终会执行QQRun的run方法
//当main线程启动了一个子线程而该子线程睡眠时，主线程不会阻塞会继续执行
//此时，主线程与子线程交替执行
System.out.println("qqRun.run()只能顺序执行，qqRun.start()可以与在它之后的语句并行/并发执行");
}
}
//当一个类继承了Thread类，该类就可以当做线程使用
//Thread类实现了Runnable接口的run方法
class QQRun extends Thread{
@Override
//重写run方法，写上自己的业务逻辑
public void run() {
System.out.println("开启一个聊天~~~~" + Thread.currentThread().getName());
//Thread.currentThread().getName()获得当前线程的名称
try {
Thread.sleep(1000);//让该线程休眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}实现Runnable接口创建线程
1、Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来创建线程显然不可能了。
2、Java设计者们提供了另外一个方式来创建线程，就是通过实现Runnable接口来创建线程
Thread2 thread2 = new Thread2();
// thread2.start();这里不能使用start方法
//创建了Thread对象，把实现了Runnable的类放入Thread
Thread thread = new Thread(thread2);
thread.start();
3、实现了Runnable接口的方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制
//多个线程共享一个资源的情况
Thread thread = new Thread(student);
thread.start();
Thread thread1 = new Thread(teacher);
thread1.start();
Thread thread2 = new Thread(student);
Thread thread3 = new Thread(teacher);
thread2.start();
thread3.start();这里底层使用了代理设计模式
package com.zdz.annotation;
/**
* @version null
* @anthor zdz/Maddox
*/
//通过实现Runnable来开发线程
public class ThreadInterface{
public static void main(String[] args) {
Thread2 thread2 = new Thread2();
// thread2.start();这里不能使用start方法
//创建了Thread对象，把实现了Runnable的类放入Thread
Thread thread = new Thread(thread2);
thread.start();//静态代理模式
}
}
class Thread2 implements Runnable{//实现Runnable接口来创建线程
int count = 0;
@Override
public void run() {
while(true) {
System.out.println("run run run~~~~~~~~~! " + (count++) + " " + Thread.currentThread().getName());
//休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10){
break;
}
}
}
}
多线程实现
package com.zdz.annotation;
/**
* @version null
* @anthor zdz/Maddox
*/
@SuppressWarnings("all")
public class Multithread {
public static void main(String[] args) {
Study student = new Study("Tom");
Study teacher = new Study("Marry");
Thread thread = new Thread(student);
thread.start();
Thread thread1 = new Thread(teacher);
thread1.start();
}
}
class Study implements Runnable{
private String name;
public Study(String name){
this.name = name;
}
int count = 0;
@Override
public void run() {
while (true) {
System.out.println("1s记一个单词" + " " + name + " 记了第 " + (count++) +
" 个单词 " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10){
System.out.println("记了" + count + "个单词");
break;
}
}
}
}
class Lean implements Runnable{
private String name;
public Lean(String name){
this.name = name;
}
int count = 0;
@Override
public void run() {
while (true) {
System.out.println("1s记一个单词" + " " + name + " 记了第 " + (count++) +
" 个单词 " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10){
System.out.println("记了" + count + "个单词");
break;
}
}
}
}
线程终止
1、当线程完成任务后会自动退出
2、还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
package com.zdz.thread;
/**
* @version null
* @anthor zdz/Maddox
*/
public class ThreadExit {
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
test.start();
//如果希望主线程去控制子线程的终止，必须修改loop变量
//让exit退出run()方法，从而终止test线程——>通知方式
//让主线程休眠十秒再通知子线程退出
System.out.println("先摸鱼10s");
Thread.sleep(10 * 1000);
test.setLoop(false);
}
}
class Test extends Thread{
private int count = 0;
//设置一个控制变量
private Boolean loop = true;
@Override
public void run() {
while (loop) {
count++;
System.out.println("每隔50毫秒输出一次 " + "第 " + count + "次");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void setLoop(boolean loop){
this.loop = loop;
}
}
线程常用方法
setName //设置线程名称，使之与参数name相同
getName //返回该线程的名称
start //使该线程开始执行
run //调用线程对象的run方法
setPriority //更改线程的优先级
getPriority //获取线程的优先级
线程优先级的范围（常量：最小1，正常5，最大10）
sleep //在指定的毫秒数内让当前执行正在执行的线程休眠（暂停执行）
interrupt //中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠的线程
sleep：线程的静态方法，是当前线程休眠
yield：线程的静态方法，表示线程的礼让，让出CPU，让其他线程执行。但礼让的时间不确定，所以不一定礼让成功
join：线程的插队。插队的线程一旦插队成功则肯定先执行完插入的线程的所有任务
sleep、wait、yield、join方法的资源使用情况
1.sleep()方法
在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。
sleep()使当前线程进入阻塞状态，在指定时间内不会执行。
2.wait()方法
在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。
唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。
waite()和notify()必须在synchronized函数或synchronized block中进行调用。如果在non-synchronized函数或non-synchronized block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
3.yield方法
暂停当前正在执行的线程对象。
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
yield()只能使同优先级或更高优先级的线程有执行的机会。
4.join方法
等待该线程终止。
等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。
用户线程和守护线程
用户线程：也叫工作线程，当线程的任务执行完成或通知方式结束
守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
常见的守护线程：垃圾回收机制
thread01.setDaemon(boolean)：让线程调用这个方法即可
线程七大状态
在java中，线程有如下图几个状态
Runnable即Ready+Running两个状态的统称
线程生命周期
Synchronized线程同步机制
1、在多线程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻 ，最多有一个线程访问，以保证数据的完整性
2、也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作。
互斥锁
1、在Java语言中，引入了对象互斥锁这个概念来保证共享数据操作的完整性
2、每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
3、关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表面该对象在任一时刻只能由一个线程访问
4、同步的局限性：导致程序的执行效率要降低
5、同步方法（非静态的）的锁可以是this（当前对象），也可以是其他对象（要求是同一个对象）
6、同步方法（静态的）的锁为当前类（该类创建的所有对象）本身
注意事项和细节
1、同步方法如果没有使用static修饰，默认锁对象为this
2、如果方法使用static修饰，默认锁对象为类名.class
3、实现的落地步骤
先分析上锁的代码
选择同步代码块或同步方法
要求多个线程的锁对象为同一个即可
死锁
OS定义：在一组进程发生死锁的情况下，这组死锁进程中的每一个进程，都在等待另一个死锁进程所占有的资源。
释放锁
下面操作会释放锁
1、当前线程的同步方法、同步代码块执行结束
2、当前线程在同步方法、同步代码块中遇到break、return
3、当前线程在同步方法、同步代码块中出现了未处理的Error、Exception，导致异常结束
4、当前线程在同步方法、同步代码块中执行了线程对象的wait方法，当前线程暂停并释放锁
下面操作不会释放锁
1、线程执行同步方法或同步代码块时，调用了sleep、yield方法只是暂停当前线程的执行不会释放锁
2、线程执行同步代码块时，其他线程调用了该线程的suspend方法将该线程挂起，不会释放锁
扫一扫
804
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
