- 关于进程和线程，首先从定义上理解就有所不同
1、进程是具有一定独立功能的程序、它是系统进行资源（内存）分配和调度的最小单位，重点在系统调度和单独的单位，也就是说进程是可以独立运行的一段程序。
2、线程是进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。
- 联系
1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。
2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。
3、线程在执行过程中，需要协作同步（生产者消费者）。不同进程的线程间要利用消息通信的办法实现同步。
4、CPU是分给线程，即真正在CPU上运行的是线程。
5、进程作为拥有资源的基本单位，线程是作为CPU调度和分配的基本单位。
6、进程是拥有资源的独立单位，线程是不拥有系统资源，但是可以访问隶属于进程的资源。
3、Java里面创建线程有四种方式
1、直接继承Thread
2、实现Runnable接口
两者最大区别就是，Java里面是单继承的，继承Thread类方式将单继承这个位置给占了，
只能去实现接口，不能再去继承别的类了，而实现Runnable接口这种方式不影响继承类也不
影响实现其他接口。
3、实现callable接口，重写call方法（有返回值）
4、线程池
4、生产者和消费者问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zbjL3Dpu-1663913311256)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/e540c98c-60ad-41f8-b8f4-397942334e7a/Untitled.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ANRBCky-1663913311258)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/eb51bd52-dd62-4ad6-b16f-a87e196f4bfa/Untitled.png)]
对于同步和异步的控制都是在Panzi这个类里面进行的，是最核心的类，生产者和消费者只是不停的生产蛋糕和吃蛋糕，不需要考虑线程的同步和异步，同步和异步的操作都是在Panzi这个类里面完成。
调用wait和notify/notifyAll都必须要加上synchronized。
notify和notifyAll都可以完成通知，notify控制比较复杂，我们直接使用notifyAll就可以。
什么时候使用wait和notifyAll：
这两个是成对出现的，我们在等待的是生产的Cake，没有Cake就wait，生产者生产了Cake之后就调用notifyAll。
多线程的编程步骤：
1、第一步：创建资源类,在资源类创建属性和操作方法（在这类Panzi就是资源类）
2、第二步：在资源类中操作方法 （Panzi里面有getCake()方法）
1、判断
2、业务代码（干活）
3、通知
3、第三步：创建多个线程，调用资源类的操作方法。 (生产者线程和消费者线程生产了蛋糕放到盘子panzi.putCake(),吃蛋糕panzi.getCake())
5、生产者和消费者问题代码实现
//Main类
public class Main {
public static void main(String[] args) {
//生产者和消费者操作的是同一个盘子
Panzi panzi = new Panzi();
//启动生产者线程去生产蛋糕
ProducerThread producerThread = new ProducerThread("生产者线程", panzi);
producerThread.start();
//启动消费者线程去吃蛋糕
ConsumerThread consumerThread = new ConsumerThread("消费者线程", panzi);
consumerThread.start();
}
}
//Cake类
public class Cake {
// 蛋糕的编号
private String name;
}
/*
* 资源类（核心类）,生产者线程ProducerThread生产了蛋糕调用putCake放到盘子里，
* 消费者线程ConsumerThread吃蛋糕就调用getCake从盘子里拿蛋糕
*/
//Panzi
public class Panzi extends Object{
// 使用LinkedList来模拟队列的结构，队列的尾部添加，队列的头部移除
private LinkedList<Cake> list = new LinkedList();
public synchronized void puCake(Cake cake) {
if(list.size() >= 2) {
try {
System.out.println("生产者线程 putCake wait");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
list.addLast(cake);
this.notifyAll();
}
public synchronized Cake getCake() {
if (list.size() <= 0) {
// 盘子里面没有蛋糕了，就需要等待生产者生产蛋糕
try {
System.out.println("消费者线程 getCake wait");
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Cake cake = list.removeFirst();
notifyAll();
return cake;
}
}
/*
* 消费者线程
*/
//ConsumerThread
public class ConsumerThread extends Thread{
private Panzi panzi;
public ConsumerThread(String name, Panzi panzi) {
super(name);
this.panzi = panzi;
}
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
Cake cake = panzi.getCake();
System.out.println(Thread.currentThread().getName() + " putCake: " + cake);
// 等待的时间是随机的，模拟吃蛋糕时间
try {
Thread.sleep(new Random().nextInt(5000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/*
* 生产者线程
*/
//ProducerThread
public class ProducerThread extends Thread{
private Panzi panzi;
public ProducerThread(String name, Panzi panzi) {
super(name);
this.panzi = panzi;
}
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
Cake cake = new Cake("no:" + i);
panzi.puCake(cake);
System.out.println(Thread.currentThread().getName() + " getCake: " + cake);
// 等待的时间是随机的，模拟吃蛋糕时间
try {
Thread.sleep(new Random().nextInt(5000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
6、Thread常用的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mk7oJLK6-1663913311259)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/4e03f969-0a29-4a85-9db7-f861a3b51b7a/Untitled.png)]
让线程暂时停止可以选择sleep方法。
比如Thread.sleep(1000),当前线程睡眠1秒。
需要知道的是，1秒后，线程是回到可执行状态，并不是执行状态，什么时候执行那是由虚拟机来决定的。
所以sleep(1000)并不是在睡眠1秒后立即执行。
7、yield
解释它之前，先简述下，多线程的执行流程：多个线程并发请求执行时，由cpu决定优先执行哪一个，即使通过thread.setPriority()，设置了线程的优先级，也不一定就是每次都先执行它
Thread.yield();，表示暂停当前线程，执行其他线程(包括执行yield这个线程)， 执行谁由cpu决定
yield这个方法是让当前线程回到可执行状态，以便让具有相同优先级的线程进入执行状态(包括这个执行yield的线程，因为其也在可执行状态)
public static native void yield();
- Yield是一个静态的原生(native)方法
- Yield告诉当前正在执行的线程把运行机会交给线程池中拥有相同优先级的线程。
- Yield不能保证使得当前正在运行的线程迅速转换到可运行的状态
- 它仅能使一个线程从运行状态转到可运行状态，而不是等待或阻塞状态
8、join
在某些情况下，如果子线程里要进行大量的耗时的运算，主线程可能会在子线程执行完之前结束，但是如果主线程又需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()。
阻塞所在线程，等调用它的线程执行完毕，再向下执行。
a.join，在API中的解释是，在B线程中调用a.join()，堵塞当前线程B，直到A执行完毕并死掉，再执行B。
线程实例的方法join()方法可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用，当前运行着的线程将阻塞直到这个线程实例完成了执行
//Waits for this thread to die.public final void join() throws InterruptedException
在join()方法内设定超时，使得join()方法的影响在特定超时后无效。
当超时时，主方法和任务线程申请运行的时候是平等的。然而，当涉及sleep时，join()方法依靠操作系统计时，所以你不应该假定join()方法将会等待你指定的时间。
像sleep,join通过抛出InterruptedException对中断做出回应。
public class JoinExample {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
public void run() {
System.out.println("First task started");
System.out.println("Sleeping for 2 seconds");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("First task completed");
}
});
Thread t2 = new Thread(new Runnable() {
public void run() {
System.out.println("Second task completed");
}
});
t1.start();
t1.join(); //Main线程等待t1线程执行完毕，在执行下面的操作
t2.start();
}
}
9、如何正确的停止线程
java中有三种停止线程方法
1)使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
2）使用stop方法方法强行终止线程，但是不推荐使用这个方法，应为stop不安全而且已经被废弃的方法，还有suspend和resume都是废弃的方法。
3）使用interrupt方法中断线程。
interrupt()方法 仅仅使线程中打了一个停止的标记，并不是真的停止线程。
this.interrupted() 测试当前线程是否已经中断。
this.isInterrupted()测试线程是否已经中断。
中断线程
线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，之后的结果：线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身，并不是一定中断这个线程。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。
193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
