Thread
进程:是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配的基本单位.进程是线程的容器.
线程: 是操作系统能够进行运算调度的最小单位,包含在进程中.
进程:系统资源分配的基本单位
线程:系统进行运算调度的最小单位
总结:
1:一个进程最起码有一个线程
2:线程之间资源贡献,线程通讯(线程间内存共享)
总结:CPU调度进程之前要准备数据 如开辟的内存,外部资源 以及运行过程中产生的一些变量和临时存储.这些和进程关联的东西称之为进程上下文.
1:线程和进程的区别?
进程是一个程序或者一个应用,线程是进程中的一个任务.进程是线程的容器.
线程方法说明:
1:thread.sleep(long)：强制线程睡眠一段时间。
2:thread.start()：启动一个线程。
3:thread.join()：在当前线程中加入指定线程，使得这个指定线程等待当前线程，并在当前线程结束前结束。
4:thread.yield()：使得当前线程退让出CPU资源，把CPU调度机会分配给同样线程优先级的线程
5:thread.interrupt()：使得指定线程中断阻塞状态，并将阻塞标志位置为true。(只改变了状态 不中断执行)
6:object.wait()、object.notify()、object.notifyAll()：Object类提供的线程等待和线程唤醒方法。
注意线程状态
1.Thread.State NEW 新建状态 : 尚未启动的线程的线程状态。Thread thread= new Thread()
2.Thread.State RUNNABLE 就绪可运行状态
1:就绪,可运行状态
1:线程创建后开启线程又可以分为准备状态和运行状态
2:就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。
3:调用线程的start()方法，此线程进入就绪状态。
4:当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
5:当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
6:锁池里的线程拿到对象锁后，进入就绪状态。
2:当CPU调度到了此线程且此线程是就绪状态 CPU调度后就是 执行状态了
3.Thread.State BLOCKED 阻塞状态 阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
线程调用synchronized 修饰的方法或者代码块 此方法在等待获取锁的时候线程 属于阻塞状态
4. Thread.State WAITING 等待状态 处于这种状态的线程不会被CPU调度 需要被显示的唤醒 否则会一直等待下去
唤醒:
1:object.wait()、object.notify()、object.notifyAll()唤醒;
2:其他线程join()导致的等待状态需要等待另外线程结束.
5: Thread.State TIMED_WAITING 倒计时等待状态 于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
成线程限时等待状态的原因有五种:
Thread.sleep(long)
Object.wait(long)
join(long)
LockSupport.parkNanos(obj,long)
LockSupport.parkUntil(obj,long)
6: Thread.State TERMINATED 结束状态 一个完全运行完成的线程的状态。也称之为终止状态、结束状态。
注意:
object.wait() join() 方法中加时间进入TIME_WAITING状态 不加时间进入WAITING状态
Thread.sleep(long)
2:线程实现.
new Thread 实现Runable接口 调用start开启线程.
继承Thread 实现Runable接口 调用start开启线程.
3:Thread run和start区别.
run:方式只是Runable接口的普通方法
start方法:开启线程
sleep 方法和 wait 方法有什么区别
sleep 是Thread的方法 wait 是Object 的方法
sleep 定时器 结束后会执行
wait 需要唤醒才执行
obj.wait(100)
1:等待
wait sleep synchronized
2:顺序
join
3:中断
只能中断状态 需要搭配 while(true) 判断状态
4:插入
join
public class ThreadUtil {
public static void start(){
Thread thread= new Thread();
System.out.println("状态:"+thread.getState());
thread.start();
System.out.println("状态:"+thread.getState());
}
public static void join(){
Thread thread= new Thread(){
@Override
public void run() {
super.run();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread1状态:"+"执行结束");
}
};
System.out.println("thread1状态:"+thread.getState());
thread.start();
System.out.println("thread1状态:"+thread.getState());
Thread thread2= new Thread(){
@Override
public void run() {
super.run();
System.out.println("thread2状态:"+"执行结束");
}
};
System.out.println("thread2:"+thread2.getState());
thread2.start();
System.out.println("thread2:"+thread2.getState());
try {
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 线程顺序执行
*/
public static void orderJoin(){
Thread thread= new Thread(){
@Override
public void run() {
super.run();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread1--->执行");
}
};
Thread thread2= new Thread(){
@Override
public void run() {
super.run();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread2--->执行");
}
};
Thread thread3= new Thread(){
@Override
public void run() {
super.run();
System.out.println("thread3--->执行");
}
};
try {
thread.start();
thread.join();
thread2.start();
thread2.join();
thread3.start();
thread3.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void yield(){
Thread thread= new Thread(){
@Override
public void run() {
super.run();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread1---> 结束");
}
};
Thread thread2= new Thread(){
@Override
public void run() {
super.run();
System.out.println("thread2---> 结束");
}
};
System.out.println("thread1状态:"+thread.getState());
thread.start();
System.out.println("thread1状态:"+thread.getState());
Thread.yield();
thread2.start();
System.out.println("thread2状态:"+thread.getState());
}
}
