多线程基础（一）
一、进程和线程的概念
- 进程：运行中的某个程序或者应用，至少包含一个线程
- 线程：进程中负责执行的一个或者多个执行单元，归属于进程，且多个线程共享进程的资源
- 并发机制：多个线程同时运行，CPU给每个线程分配时间片，获得时间的线程运行，其他线程等待，由于时间片很短，从宏观上看是线程都在运行，微观上看是线程走走停停
二、线程的创建
1、继承Thread类，重写run()
public class MyThread extends Thread{
private String name;
MyThread(String name){
this.name=name;
}
@Override
public void run(){
System.out.println("name"+name+",此线程的id为"+Thread.currentThread().getId());
}
public static void main(String[] args) {
System.out.println("当前主线程id为："+Thread.currentThread().getId());
MyThread myThread1 = new MyThread("线程1");
myThread1.start();
MyThread myThread2 = new MyThread("线程2");
myThread2.run();
}
}
输出如下：
image.png
小结：
- start()和run()方法的不同。start是启动线程，交给CPU去获取时间片并调用run方法。而用run方法相当于交给主线程去执行run，并不会创建新的线程。
- 线程1是先创建的，但是输出结果在后，说明线程的创建并不会阻塞主线程的执行
2、实现Runnable接口
public class MyRunnable implements Runnable {
private String name;
MyRunnable(String name){
this.name = name;
}
public void run() {
System.out.println("启动"+name+"：id为"+Thread.currentThread().getId());
}
public static void main(String[] args) {
MyRunnable my = new MyRunnable("runnable线程");
Thread thread = new Thread(my);
thread.start();
}
}
3、最简洁的启动线程的方式
new Thread(new Runnable(){
public void run(){
xxxxxx
}
};).start();
三、线程的状态
- 创建（new）状态: 准备好了一个多线程的对象
- 就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
- 运行（running）状态: 执行run()方法
- 阻塞（blocked）状态: 暂时停止执行, 可能将资源交给其它线程使用
- 终止（dead）状态: 线程销毁
image.png
1、当线程进入就绪状态后，要等CPU分配到时间片之后，线程便真正进入运行状态。
2、线程在运行状态过程中，可能有多个原因导致当前线程不继续运行下去，比如用户主动让线程睡眠（睡眠一定的时间之后再重新执行）、用户主动让线程等待，或者被同步块给阻塞，此时就对应着多个状态：time waiting（睡眠或等待一定的事件）、waiting（等待被唤醒）、blocked（阻塞）。
3、当由于突然中断或者子任务执行完毕，线程就会被消亡。
注:sleep和wait的区别:
- sleep是Thread类的方法,wait是Object类中定义的方法.
- Thread.sleep不会导致锁行为的改变, 如果当前线程是拥有锁的, 那么
Thread.sleep不会让线程释放锁. - Thread.sleep和Object.wait都会暂停当前的线程. OS会将执行时间分配给其它线程. 区别是, 调用wait后, 需要别的线程执行notify/notifyAll才能够重新获得CPU执行时间.
四、线程API
1、sleep():线程休眠，且不会释放锁。
public class MyThreadAPI{
private int i = 0;
private Object object = new Object();
public static void main(String[] args) {
MyThreadAPI api = new MyThreadAPI();
MyThreadSleep thread1 = api.new MyThreadSleep() ;
MyThreadSleep thread2 = api.new MyThreadSleep() ;
thread1.start();
thread2.start();
}
class MyThreadSleep extends Thread{
public void run(){
synchronized (object) {
i++;
System.out.println(Thread.currentThread().getName()+"睡眠前i："+i);
System.out.println(Thread.currentThread().getName()+"进入睡眠");
try {
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"睡眠结束");
i++;
System.out.println(Thread.currentThread().getName()+"睡眠后i："+i);
}
}
}
}
输出结果：
image.png
2、yield(),让出当前时间片，与sleep不同的是不可选择时间
public class MyThreadYeild extends Thread {
public void run(){
long start = System.currentTimeMillis();
int count = 0;
for(int i = 1;i<50000000;i++){
count++;
Thread.yield();
}
System.out.println("当前count为："+count);
long end = System.currentTimeMillis();
System.out.println("耗时："+(end-start)+"毫秒");
}
public static void main(String[] args) {
MyThreadYeild thread = new MyThreadYeild();
thread.start();
}
}
输出可发现：不写thread.yield()方法时，执行时间较短
线程的sleep()方法和yield()方法有什么区别？
① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
② 线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；
③ sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；
④ sleep()方法比yield()方法（跟操作系统CPU调度相关）具有更好的可移植性。
3、join()方法
主线程创建并启动了线程，如果子线程中要进行大量耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。
public class MyThread4 extends Thread {
public MyThread4(String name){
super(name);
}
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) throws InterruptedException {
// 启动子进程
for (int i = 0; i < 10; i++) {
if (i == 5) {
MyThread4 th = new MyThread4("joined thread");
th.start();
th.join();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
输出如下：
image.png
4、interrupt线程中断
public void interrupt(); 中断线程。
public static boolean interrupted(); 是一个静态方法，用于测试当前线程是否已经中断，并将线程的中断状态 清除。所以如果线程已经中断，调用两次interrupted，第二次时会返回false，因为第一次返回true后会清除中断状态。
五、守护线程
线程分为用户线程和守护线程，当用户线程结束，守护线程会被强制终止。GC就是守护线程，默认线程是用户线程，在启动前可设置为守护
