Java多线程的操作,比如yield方法

使用Thread（变成卖各自的票）或者是Runnable（只卖10张票）实现线程的共享

一、线程的命名与取得

public class TestThread14 {
    public static void main(String[] args) {
        MyThread6 mt=new MyThread6();
        // 没有设置名字，会自动分配一个线程名字
        // 线程名字如果要设置请避免重复，同时中间不要修改
        //这俩个执行的时候不按照顺序
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt,"java").start();
        //直接调用对象的run方法
        mt.run();
    }
}
class MyThread6 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            //取得线程名字
            System.out.println("当前线程"+Thread.currentThread().getName()+",i="+i);
        }
    }
}

二、线程休眠(sleep方法)

休眠时由运行态到阻塞态；休眠结束后由阻塞态到就绪态

线程休眠：指的是让线程暂缓执行一下，等到了预计时间之后再恢复执行。线程休眠会立马交出CPU，让CPU去执行其他的任务。但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，即使调用sleep方法，其他线程也无法访问这个对象public static native void sleep (long millis) throws InterruptedException

//是依次进入到run()方法中的
//真正进入到方法的对象可能是多个，也可能是一个。进入代码的顺序可能有差异，但是总体执行是并发执行的,
public class TestThread15 {
    public static void main(String[] args) {
        MyThread7 mt = new MyThread7();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}
class MyThread7 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("当前线程" + Thread.currentThread().getName() + ",i=" + i);
        }
    }
}
当前线程Thread-1,i=0
当前线程Thread-0,i=0
当前线程Thread-2,i=0
当前线程Thread-1,i=1
当前线程Thread-0,i=1
当前线程Thread-2,i=1
.....

三、线程让步(yield方法)

由运行态到就绪态，停止一下后再由就绪态到运行态

• 暂停当前正在执行的线程对象，并执行其他线程。
• 意思就是调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。
• 但是yield不能立刻交出CPU，会出现同一个线程一直执行的情况，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
• 注意调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的

public class TestThread16 {
    public static void main(String[] args) {
        MyThreadTest mt = new MyThreadTest();
        new Thread(mt,"1").start();
        new Thread(mt,"2").start();
        new Thread(mt,"3").start();
    }
}

class MyThreadTest implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            Thread.yield();
            System.out.println("当前线程：" + Thread.currentThread().getName()+" ,i = "
                    +i);
        }
    }
}
无序

四、join方法

运行态到阻塞态（释放锁），线程执行完毕后阻塞态到就绪态

等待该线程终止。意思就是如果在主线程中调用该方法时就会让主线程休眠，让调用该方法的线程run方法先执行完毕之后在开始执行主线程，不使用join方法的话主和子一起执行，main开始，main结束，子线程方法。本质是对Object类的wait方法做了包装。

public class TestThread18 {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("main开始");
        MyThread0 mt = new MyThread0();
        Thread thread = new Thread(mt, "子线程A");
        thread.start();
        thread.join();
        System.out.println("main结束");
    }

    public static void printTime() {
        Date date=new Date();
        DateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time=format.format(date);
        System.out.println(time);
    }
}

class MyThread0 implements Runnable {

    @Override
    public void run() {
        try {
            System.out.println("主线程睡眠前的时间");
            TestThread18.printTime();
            Thread.sleep(2000);
            System.out.println("主线程睡眠结束的时间");
            TestThread18.printTime();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
main开始
主线程睡眠前的时间
2019-03-01 18:28:20
睡眠结束的时间
2019-03-01 18:28:22
main结束