线程礼让

让当前正在执行的线程暂停，但不阻塞；

将线程运行状态转为就绪状态；礼让不一定成功，得看CPU的心情； Thread.yield();——使用的方法

package Stop;
?
public class TeastYied {
    public static void main(String[] args) {
        MyYied my=new MyYied();
        new Thread(my,"第一条").start();
        new Thread(my,"第二条").start();
    }
?
}
class MyYied implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

线程的强制执行 join

Join合并线程，待此线程执行完了在执行其他线程，其他线程阻塞；（插队，老VIP了） join

package Stop;
?
public class TestJoin  implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("插个队"+i);
        }
    }
?
    public static void main(String[] args) throws InterruptedException {
        TestJoin j1=new TestJoin();
        Thread j2=new Thread(j1);
        j2.start();
        for (int i = 0; i < 1000; i++) {
            if(i==100){
                j2.join();
            }
            System.out.println(i);
?
        }
    }
}

线程的状态：

new->就绪状态->运行状态（可能会阻塞，阻塞之后就绪状态）->死亡状态

一旦死亡就不可以再次启动；

线程的优先级：

通过getPriority().setPriority(int ..); 可以改变或者获取优先级；

先设置优先级在启动；

package Stop;
?
public class TestPriority {
?
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority());
        myPriority my=new myPriority();
        Thread m1=new Thread(my);
        Thread m2=new Thread(my);
        Thread m3=new Thread(my);
        Thread m4=new Thread(my);
        m1.setPriority(2);
        m1.start();
        m2.setPriority(Thread.MAX_PRIORITY);  //10
        m2.start();
        m3.setPriority(5);
        m3.start();
        m4.setPriority(3);
        m4.start();
?
    }
}
class myPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority());
    }
}

main的优先级是5；最高为10；默认为5；

守护（daemon）线程

线程分为用户线程和守护线程；

虚拟机必须确保用户线程执行完毕；-不用等守护线程结束；

默认的Daemon为false,即用户线程，需要自己设置为守护线程（true）;

package Stop;
?
public class TestDeomen {
    public static void main(String[] args) {
        god g1=new god();
        Thread g2=new Thread(g1);
        g2.setDaemon(true);
        g2.start();
        user u1=new user();
        Thread u2=new Thread(u1);
        u2.start();
?
    }
?
}
class god implements Runnable{
    @Override
    public void run() {
        while (true)
        System.out.println("我是守护线程");
    }
}
?
class user implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("用户线程！");
        }
    }
}

线程的同步机制

多个线程操作同一个资源；

并发：同一个对象被多个线程同时操作；

当多个对象想修改这个对象的时候，就需要线程同步，即一种等待机制，多个对象进入对象的等待池

形成队列；

形成条件：队列+锁 ---保证线程的安全

锁机制synchronized,独占资源；

线程同步会影响性能问题(效率)但是安全；

java基础之线程篇（三）