目录
一、进程
1.进程的概述
概述：运行起来的程序就是进程。如：打开qq、微信则是开启进程
2.进程的特点
特点：进程与进程之间的资源是独立的，进程是操作系统分配的基本单位
3.多进程
概述：同时可以运行多个程序，"宏观并行，微观串行"：在一个时间段可以看成多个进程是同时在运行的，但是从微观上，一个时间点是运行一个进程的，只是它们切换的速度特别快，所以让我们产生一种错觉，它们是同时运行的。
二.线程
1.线程的概述
进程：进程里面的一条执行路径；如果有多条执行路径，则是多线程
现实中的进程与线程：
进程：我们打开qq音乐，再打开百度网盘，每次打开一个软件就是开启一个进程
线程:我们打开qq音乐后，在qq音乐下载多首歌曲，每首歌曲的下载就是开启一个线程
特点：在qq音乐这个进程中的每首歌曲下载的进程会互相抢占资源，所以每首歌曲的下载速度有快有慢
2.进程与线程的区别
进程是系统分配的基本单位；线程是cpu调度的基本单位
一个进程一般是会有多个线程的，至少会有一个线程
进程间的资源是互相独立的；进程中的多个线程资源是共享的
question:从main方法出发，执行的代码是多线程还是单线程？
答：多线程，因为在后台会有一个守护线程跟着main方法一起执行
什么是守护线程？
守护线程就是守护主线程的，主线程存在，守护线程也存在；主线程不存在，则守护线程也停止（垃圾回收器就在守护线程中）
3.线程的组成
cpu时间片：多个线程互抢cpu资源，谁抢到谁执行
运行的数据:
栈数据:在线程中执行的局部变量------天生线程安全(多个线程互抢资源和局部变量无关)
堆数据:
在线程中执行的成员变量---多线程互抢资源，需要考虑堆数据的安全性
执行的代码：一些线程中的逻辑代码
三、线程创建
1.继承Thread
通过继承Thread创建线程的案例:
继承后重写run方法
//线程的创建：继承Thread
//案例：主线程(main的执行路径)和子线（创建的）程都打印1~200；查看执行的结果
class MyThread extends Thread{
@Override
public void run() { //run中的执行就是子线程的执行
for(int i=1;i<=200;i++) {
System.out.println("子线程..."+i);
}
}
}启动线程的主线程案例:
public class Test1 {
public static void main(String[] args) {
//创建子线程的注意事项：1.子线程的创建要放到主线程执行前面 2.调start方法
MyThread thread = new MyThread();
//将当前线程对象放入线程组，供cpu调度；当cpu调度到你，则你执行；调度到其他线程，则就绪状态
thread.start();
//thread.start(); //new一次线程对象，不能多次调用，否则报错
new MyThread().start(); //new多次线程对象，多次调用，则不会有问题
for(int i=1;i<=200;i++) {
System.out.println("主线程..."+i);
}
}
}new一次线程对象，不能多次调用，否则报错
在第二次调用 start() 方法的时候，线程可能处于终止或者其他（非 NEW）状态，但是不论如何，都是不可以再次启动的。
而new多次线程对象，自然可以多次调用start方法，因为调用的都是对象自身的start方法，没有冲突
2.实现Runnable接口
通过实现Runnable接口创建线程的案例：
实现接口后，重写run方法
//线程的创建：实现任务的方式
//案例：主线程(main的执行路径)和子线（创建的）程都打印1~200；查看执行的结果
class Task implements Runnable{
@Override
public void run() {
for(int i=1;i<=200;i++) {
System.out.println("子线程..."+i);
}
}
}启动线程的主线程案例:
public class Test2 {
public static void main(String[] args) {
Thread th = new Thread(new Task()); //传入任务对象
th.start();
for(int i=1;i<=200;i++) {
System.out.println("主线程..."+i);
}
}
}3.线程的状态
基本状态：
new线程(初始状态)---调start--->就绪状态<----cpu调度run-->执行状态--->线程终止
四、线程的方法
1.优先级与sleep
线程的优先级，可以改变线程的执行的效率；但不是绝对性可以改变哪个线程先执行完
线程优先级的设置及睡眠案例:
//线程的优先级： 优先级高，则大概率先执行完，但不绝对
//案例：两个子线程都打印1~200；查看执行的结果
class MyThread extends Thread{
public MyThread(String name) {
super(name); //值传给父类
}
@Override
public void run() {
for(int i=1;i<=200;i++) {
try {
Thread.sleep(1); //睡眠-单位毫秒； 好处复现线程抢占效果
} catch (InterruptedException e) {}
System.out.println(getName()+"..."+i); //调用父类name值
}
}
}
public class Test1 {
public static void main(String[] args) {
MyThread thread = new MyThread("线程1");
thread.setPriority(Thread.MAX_PRIORITY); //设置高优先级
thread.start();
MyThread thread2 = new MyThread("线程2");
thread2.setPriority(Thread.MIN_PRIORITY); //设置低优先级
thread2.start();
}
}2.线程礼让
线程礼让yield：中断当次线程，继续和其他资源争抢； 礼让的线程相对会执行的慢一些，但不是绝对性的。
线程礼让案例:
//线程的礼让：
//案例：两个子线程都打印1~200；其中一个线程每次执行都进行礼让，查看执行的结果
class A extends Thread{
@Override
public void run() {
for(int i=1;i<=200;i++) {
Thread.yield(); //线程礼让；理论上会执行得慢一点
System.out.println("线程A..."+i);
}
}
}
class B extends Thread{
@Override
public void run() {
for(int i=1;i<=200;i++) {
System.out.println("线程B..."+i); //调用父类name值
}
}
}
public class Test2 {
public static void main(String[] args) {
new A().start();
new B().start();
}
}3.线程合并
线程合并join，也叫插队； 插队的线程绝对性的先执行完
插队的线程肯定先执行
应用场景： 子线程插主线程的队
线程插队案例：
//线程插队：
//案例：子线程和主线程各打印1~200；主线程执行到5，让子线程插队先执行完，查看执行的结果
class MyTh extends Thread{
@Override
public void run() {
for(int i=1;i<=200;i++) {
System.out.println("子线程..."+i);
}
}
}
public class Test3 {
public static void main(String[] args) throws InterruptedException {
MyTh th = new MyTh();
th.start();
for(int i=1;i<=200;i++) {
System.out.println("主线程线程..."+i);
if(i==5) {
th.join(); //子线程插队
}
}
}
}4.线程的状态
线程的基本状态+等待状态
在基本状态的基础上，运行状态里面可以进入等待状态
有限期等待sleep: 等待睡眠毫秒值结束，即可进入到就绪状态； 放到主线程则主线程休眠，放到子线程则子线程休眠
无限期等待join：插队的线程执行完后，即可进入就绪状态；没有执行完，则一直等待下去
五、线程安全
概述：
在多线程的执行中，如果出现了共享数据，且共享数据进行了复合操作，则这样的共享数据就有安全隐患 （多个线程对数据进行操作，可能会操作的很乱）
例如：前面学习集合ArrayList，就是线程不安全的，我们可以模拟集合的不安全性
对加锁的理解：
当多个线程进行操作的时候，可能会导致在方法中出现复合操作，解决办法就是对可能出现复合操作的地方加锁，当一个线程访问到这个地方的时候则上锁，另一个线程也想访问这个部分的时候，必须等待这个线程访问完出来，将锁资源释放，这样就可以保证多个线程之间的操作是有序的；而让线程实现这样的功能则需要加同样的锁：就如同上厕所，一个人去上厕所后，需要将门锁住，这样别人就不会来打扰自己，必须等待自己上完厕所，开锁后别人才可以进来，但是如果两把锁不一样的，一个人上厕所上锁后，另一个人上厕所根本就不是打开你的锁，自然可以不用等待，直接去另一个坑位。
应用案例:
//案例：模拟ArrayList集合在多线程中的不安全性
//安全隐患：通过睡眠可以复现出问题
//共享数据：a，index--两个线程都会执行到；且在方法中会有复合操作篡改数据
//处理： 加锁，将共享数据的操作锁住
//锁的分类：同步代码块，同步方法
//同步代码块： synchronized
//锁的注意事项：1.同一把锁-同一个锁对象 2.锁的范围
class MyList{
String[] a = {null,null};
int index = 0;
public void add(String value) {
//this代表调用add方法的外围list对象，能确保同一个对象
synchronized (this) { //字符串常量 this.getClass()
a[index] = value;
try {
Thread.sleep(8); //睡眠-复现问题
} catch (InterruptedException e) {}
index++;
}
}
}
public class Test1 {
public static void main(String[] args) throws InterruptedException {
MyList list = new MyList();
Thread th1 = new Thread(new Runnable() {
@Override
public void run() {
list.add("hello");
}
});
th1.start();
Thread th2 = new Thread(new Runnable() {
@Override
public void run() {
list.add("world");
}
});
th2.start();
th1.join(); th2.join(); //两个子线程都需要插主线程的队
System.out.println(Arrays.toString(list.a));
}
}锁的类型
实例锁：也就是对象锁 ，当出现new多次的对象传入，这时的锁对象则不是同一个锁
类对象锁:当对象都是同一个类的实例时，它们的类对象是同一个，因为不管多少个实例对象，它们都是属于同一个类，类对象是只有一份 的 .class文件只有一个
常量锁：synchronized (“lock”) 不管哪个线程对象访问到这里它们都是同一把“lock”常量锁，常量在常量池中也只有一份
扫一扫
9147
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
