一、并发、并行、进程、线程的概念
并发和并行
- 并发 ：指两个或多个事件在同⼀个时间段内发⽣。
- 并行：指两个或多个事件在同⼀时刻发⽣（同时发⽣）。
在多个 CPU 系统中，则这些可以并发执⾏的程序便可以分配到多个处理器上（CPU），实现多任务并⾏执⾏，即利⽤每个处理器来处理⼀个可以并发执⾏的程序，这样多个程序便可以同时执⾏。⽬前电脑市场上说的多核 CPU，便是多核处理器，核 越多，并⾏处理的程序越多，能⼤⼤的提⾼电脑运⾏的效率。
注意：单核处理器的计算机肯定是不能并⾏的处理多个任务的，只能是多个任务在单个CPU上
并发运⾏。同理,线程也是⼀样的，从宏观⻆度上理解线程是并⾏运⾏的，但是从微观⻆度上分
析却是串⾏运⾏的，即⼀个线程⼀个线程的去运⾏，当系统只有⼀个CPU时，线程会以某种顺
序执⾏多个线程，我们把这种情况称之为线程调度。
线程和进程
-
进程：是指⼀个内存中运⾏的应⽤程序，每个进程都有⼀个独⽴的内存空间，⼀个应⽤程序可以同时运⾏多个进程；进程也是程序的⼀次执⾏过程，是系统运⾏程序的基本单位；系统运⾏⼀个程序，即是⼀个进程从创建、运⾏到消亡的过程。
-
线程：线程是进程中的⼀个执⾏单元，负责当前进程中程序的执⾏，⼀个进程中⾄少有⼀个线程。⼀个进程中是可以有多个线程的，这个应⽤程序也可以称之为多线程程序。
简⽽⾔之：⼀个程序运⾏后⾄少有⼀个进程，⼀个进程中可以包含多个线程
我们可以再电脑底部任务栏，右键----->打开任务管理器,可以查看当前任务的进程：
进程
线程：
线程调度：
- 分时调度
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。 - 抢占式调度
优先让优先级⾼的线程使⽤ CPU，如果线程的优先级相同，那么会随机选择⼀个(线程随机性)，Java使⽤的为抢占式调度。
⼤部分操作系统都⽀持多进程并⾏运⾏，现在的操作系统⼏乎都⽀持同时运⾏多个程序。⽐如：现在我们上课⼀边使⽤编辑器，⼀边使⽤录屏软件，同时还开着画图板，dos窗⼝等软件。此时，这些程序是在同时运⾏，”感觉这些软件好像在同⼀时刻运⾏着“。
实际上，CPU(中央处理器)使⽤抢占式调度模式在多个线程间进⾏着⾼速的切换。对于CPU的⼀个核⽽⾔，某个时刻，只能执⾏⼀个线程，⽽ CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同⼀时刻运⾏。
其实，多线程程序并不能提⾼程序的运⾏速度，但能够提⾼程序运⾏效率，让CPU的使⽤率更⾼。
二、创建线程
继承Thread类
- 定义Thread类的⼦类，并重写该类的run()⽅法，该run()⽅法的⽅法体就代表了线程需要完成的任务,因此把run()⽅法称为线程执⾏体。
- 创建Thread⼦类的实例，即创建了线程对象
- 调⽤线程对象的start()⽅法来启动该线程
示例：
public class MyThread extends Thread {
//定义指定线程名称的构造⽅法
public MyThread(String name) {
//调⽤⽗类的String参数的构造⽅法，指定线程的名称
super(name);
}
/**
* 重写run⽅法，完成该线程执⾏的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println(getName()+"："+i);
}
}
}
测试代码：
public class Demo1 {
public static void main(String[] args) {
//创建⾃定义线程对象
MyThread mt = new MyThread("新建的线程");
//开启新线程
mt.start();
//在主⽅法中执⾏for循环
for (int i = 0; i < 10; i++) {
System.out.println("主线程："+i);
}
}
}
实现Runnable接口
- 定义Runnable接⼝的实现类，并重写该接⼝的run()⽅法，该run()⽅法的⽅法体同样是该线程的线程执⾏体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
- 调⽤线程对象的start()⽅法来启动线程。
示例：
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
测试：
public class Demo2 {
public static void main(String[] args) {
//创建⾃定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread(mr, "新建的线程");
t.start();
for (int i = 0; i < 20; i++) {
System.out.println("主线程" + i);
}
}
}
继承Thread 和实现Runnable的区别
如果⼀个类继承Thread，则不适合资源共享。但是如果实现了Runable接⼝的话，则很容易的实现资源共享。
总结：实现Runnable接⼝⽐继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同⼀个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独⽴。
三、线程常用方法
| 方法名 | 说明 |
|---|---|
| public static void sleep(long millis) | 当前线程主动休眠 millis 毫秒。 |
| public static void yield() | 当前线程主动放弃时间⽚，回到就绪状态 |
| public final void join() | 允许其他线程加⼊到当前线程中 |
| public void setPriority(int) | 设置优先级 |
| public void setDaemon(boolean) | 设置守护线程 |
线程的优先级
- 我们可以通过传递参数给线程的 setPriority() 来设置线程的优先级别
- 调整线程优先级：Java线程有优先级，优先级⾼的线程会获得较多的运⾏机会。
- 优先级 : 只能反映线程的紧急程度 , 不能决定是否⼀定先执⾏。
Java线程的优先级⽤整数表示，取值范围是1~10，Thread类有以下三个静态常量：
static int MAX_PRIORITY
线程可以具有的最⾼优先级，取值为10。
static int MIN_PRIORITY
线程可以具有的最低优先级，取值为1。
static int NORM_PRIORITY
分配给线程的默认优先级，取值为5。
示例：
/**
* 优先级
*
*/
public class PriorityThread extends Thread{
@Override
public void run() {
for(int i=0;i<50;i++) {
System.out.println(Thread.currentThread().getName()+"============"+i);
}
}
}
测试：
public class TestPriority {
public static void main(String[] args) {
PriorityThread p1=new PriorityThread();
p1.setName("p1");
PriorityThread p2=new PriorityThread();
p2.setName("p2");
PriorityThread p3=new PriorityThread();
p3.setName("p3");
p1.setPriority(1);
p3.setPriority(10);
//启动
p1.start();
p2.start();
p3.start();
}
}
线程的休眠
使⽤线程的 sleep() 可以使线程休眠指定的毫秒数,在休眠结束的时候继续执⾏线程。
示例：
class SleepThread extends Thread
{
@Override
public void run()
{
String[] names = new String[]{"zs","ls","ww","z6"};
int index = (int)(Math.random()*4);
for (int i = 3;i > 0;i--)
{
System.out.println(i);
try
{
Thread.sleep(1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("倒计时："+i);
}
System.out.println("抽中学员为:"+names[index]);
}
}
测试：
public class TestSleep {
public static void main(String[] args)
{
new SleepThread().start();
}
}
线程的让步
Thread.yield()⽅法作⽤是：暂停当前正在执⾏的线程对象（及放弃当前拥有的cup资源），并执⾏其他线程。yield()做的是让当前运⾏线程回到可运⾏状态，以允许具有相同优先级的其他线程获得运⾏机会。因此，使⽤yield()的⽬的是让相同优先级的线程之间能适当的轮转执⾏。但是，实际中⽆法保证yield()达到让步⽬的，因为让步的线程还有可能被线程调度程序再次选中。- 案例:创建两个线程A,B,分别各打印1000次,从1开始每次增加1,其中B⼀个线程,每打印⼀次,就yield⼀次,观察实验结果。
示例:
class Task1 implements Runnable{
@Override
public void run() {
for (int i = 0;i < 200;i++){
System.out.println("A:"+i);
}
}
}
class Task2 implements Runnable{
@Override
public void run() {
for (int i = 0;i < 10;i++){
System.out.println("B:"+i);
Thread.yield();
}
}
}
public class Demo {
public static void main(String[] args) {
new Thread(new Task2()).start();
new Thread(new Task1()).start();
}
}
sleep()和yield()的区别
sleep()使当前线程进⼊停滞状态，所以执⾏sleep()的线程在指定的时间内肯定不会被执⾏；
yield()只是使当前线程重新回到可执⾏状态，所以执⾏yield()的线程有可能在进入到可执行状态后马上又被行。
sleep ⽅法使当前运⾏中的线程睡眼⼀段时间，进⼊不可运⾏状态，这段时间的⻓短是由程序设定的，yield ⽅法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()⽅法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运⾏状态，如有，则把 CPU的占有权交给此线程，否则，继续运⾏原来的线程。所以yield()⽅法称为“退让”，它把运⾏机会让给了同等优先级的其他线程。
另外，sleep ⽅法允许较低优先级的线程获得运⾏机会，但 yield() ⽅法执⾏时，当前线程仍处在可运⾏状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在⼀个运⾏系统中，如果较⾼优先级的线程没有调⽤ sleep ⽅法，⼜没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较⾼优先级的线程运⾏结束，才有机会运⾏。
线程的合并
- Thread 中，
join()⽅法的作⽤是调⽤线程等待该线程完成后，才能继续往下运⾏。 - join是Thread类的⼀个⽅法，启动线程后直接调⽤，即join()的作⽤是：“等待该线程终⽌”，这⾥需要理解的就是该线程是指的主线程等待⼦线程的终⽌。也就是在⼦线程调⽤了join()⽅法后⾯的代码，只有等到⼦线程结束了才能执行。
- 为什么要用
join()方法
在很多情况下，主线程⽣成并起动了⼦线程，如果⼦线程⾥要进⾏⼤量的耗时的运算，主线程往往将于⼦线程之前结束，但是如果主线程处理完其他的事务后，需要⽤到⼦线程的处理结果，也就是主线程需要等待⼦线程执⾏完成之后再结束，这个时候就要⽤到join()⽅法了。
示例：
class JoinThread extends Thread{
public JoinThread(String name){
super(name);
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始运⾏");
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"-->⼦线程："+i);
}
System.out.println(Thread.currentThread().getName()+"线程结束运⾏");
}
}
public class JoinDemo {
public static void main(String[] args) {
System.out.println("主线程开始运⾏。。。");
JoinThread t1 = new JoinThread("新加⼊的线程");
t1.start();
// try {
// t1.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println("主线程开始结束。。。");
}
}
四、守护线程
守护线程.setDaemon(true):设置守护线程；
线程有两类：⽤户线程（前台线程）、守护线程（后台线程）；
如果程序中所有前台线程都执⾏完毕了，后台线程会⾃动结束；
垃圾回收器线程属于守护线程。
public class DeamonThread extends Thread {
@Override
public void run() {
for(int i=0;i<50;i++) {
System.out.println(Thread.currentThread().getName()+"----------"+i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
测试：
public class TestDeamon {
public static void main(String[] args) {
//创建线程(默认前台线程)
DeamonThread d1=new DeamonThread();
//设置线程为守护线程
d1.setDaemon(true);//主线程结束便结束了
d1.start();
for(int i=0;i<10;i++) {
System.out.println("主线程:----------"+i);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
五、线程的生命周期
五种基本状态
当线程被创建并启动以后，它既不是⼀启动就进⼊了执⾏状态，也不是⼀直处于执⾏状态。
新建状态（New）
当线程对象对创建后，即进⼊了新建状态，如： Thread t = new MyThread();
就绪状态（Runnable）
当调⽤线程对象的start()⽅法（ t.start(); ），线程即进⼊就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了 t.start() 此线程⽴即就会执行；
运行状态（Running）
当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执⾏，即进⼊到运⾏状态。注：就绪状态是进⼊到运⾏状态的唯⼀⼊⼝，也就是说，线程要想进⼊运⾏状态执行，⾸先必须处于就绪状态中；
阻塞状态（Blocked）
处于运⾏状态中的线程由于某种原因，暂时放弃对CPU的使⽤权，停⽌执⾏，此时进⼊阻塞状态，直到其进⼊到就绪状态，才 有机会再次被CPU调⽤以进⼊到运⾏状态。根据阻塞产⽣的原因不同，阻塞状态又可以分为三种：
1.等待阻塞：运⾏状态中的线程执⾏wait()⽅法，使本线程进⼊到等待阻塞状态；
2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占⽤)，它会进⼊同步阻塞状态；
3.其他阻塞 – 通过调⽤线程的sleep()或join()或发出了I/O请求时，线程会进⼊到阻塞状态。当sleep()状态超时、join()等待线程终⽌或者超时、或者I/O处理完毕时，线程重新转⼊就绪状态。
死亡状态（Dead）
线程执⾏完了或者因异常退出了run()⽅法，该线程结束⽣命周期。
多线程状态之间的转换
就绪状态转换为运⾏状态：当此线程得到处理器资源；
运⾏状态转换为就绪状态：当此线程主动调⽤yield()⽅法或在运⾏过程中失去处理器资源。
运⾏状态转换为死亡状态：当此线程线程执⾏体执⾏完毕或发⽣了异常。
此处需要特别注意的是：当调⽤线程的yield()⽅法时，线程从运⾏状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有⼀定的随机性，因此，可能会出现A线程调⽤了yield()⽅法后，接下来CPU仍然调度了A线程的情况。
1213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
