Java------多线程_插队join
线程停止
1.不使用JDK提供的stop()/destory()方法（他们本身也被JDK废弃）。
2.提供一个boolean型的终止变量，当这个变量置为false，则终止线程。
示例代码：
/**
* 终止线程
* 1.线程正常执行完毕--》次数
* 2.外部干涉，加入标识，不要使用stop、destory，
*/
public class ThreadStop implements Runnable{
private boolean flag = true;
private String name;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println(name+"---"+i++);
}
}
public void terminte(){
this.flag = false;
}
public static void main(String[] args) {
ThreadStop stop1 = new ThreadStop();
new Thread(stop1).start();
for (int i =0;i<100;i++){
if(i==88){
stop1.terminte();
System.out.println(i);
}
}
}
}
sleep暂停
1.sleep时间指定当前线程阻塞的毫秒数；
2.sleep存在异常InterruptedException。
3.时间达到后线程进入就绪状态，等待CPU调用
4.sleep可以模拟网络延时、倒计时等，是静态方法，写在那个线程体中，那个线程阻塞。
5.每一个对象都有一个锁，sleep不会释放锁。
之前模拟抢票的例子，此处示例代码：
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 模拟倒计时，10秒倒计时
*/
public class ThreadSleep02{
public static void main(String[] args) throws InterruptedException {
//倒数10个数，1秒1个
Date endTime = new Date(System.currentTimeMillis()+1000*10);
long end = endTime.getTime();
while (true){
System.out.println(new SimpleDateFormat("mm:ss").format(endTime));
//sleep是一个静态方法，写在那个线程体中，谁运行我谁阻塞，不会释放锁，阻塞的一种
Thread.sleep(1000);
endTime = new Date(endTime.getTime()-1000);
if (end-10000 >endTime.getTime()){
break;
}
}
}
public static void test() throws InterruptedException{
//倒数10个数，1秒1个
int num = 10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
}
}
}
礼让线程yield
1.礼让线程，让当前正在执行线程暂停
2.不是阻塞线程，而是将线程从运行状态转入就绪状态
3.让cpu调度器重新调度
示例代码1：
/**
* yield礼让，
* 线程礼让后，进入就绪状态，可能立马执行，也能让其他线程先执行
* 由CPU调度
*/
public class ThreadYield {
public static void main(String[] args) {
MyYeild myYeild = new MyYeild();
new Thread(myYeild,"a").start();
new Thread(myYeild,"b").start();
}
}
class MyYeild implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"---start");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"---end");
}
}
示例代码2：
由此可见，礼让线程并比一定让出执行。
/**
* yield礼让，
* 线程礼让后，进入就绪状态，可能立马执行，也能让其他线程先执行
* 由CPU调度
*/
public class ThreadYield {
public static void main(String[] args) {
new Thread(() ->{
for (int i = 0;i<100;i++){
System.out.println("i线程-----"+i);
}
}).start();
for (int y = 0;y<100;y++){
if (y%20 ==0){
//main线程礼让
Thread.yield();
}
System.out.println("main线程------"+y);
}
}
}
join合并线程（插队线程），待此线程执行完成后，再执行其他线程，其他线程阻塞。
join是成员方法，哪个线程对象调用该方法，该线程就先执行。
join()中可以传时间，当时间到了之后，如果该线程还没有执行完，cpu就不管了，失去了优先执行的地位。
示例代码
/**
* join合并线程、插队线程
*/
public class ThreadJoin implements Runnable{
@Override
public void run() {
}
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println("-----------" + i);
}
});
thread.start();
for (int y = 0;y<100;y++){
if (y== 20){
thread.join();//插队 main被阻塞，当y==20时被阻塞，先执行i，执行完毕后，再执行y
}
System.out.println("main----------"+y);
}
}
}