多线程

/**Thread中的常用方法：
 *1:start()方法：启动线程，调用当前线程搞得run方法
 *2:run()方法：通常需要重写Thread中的此方法，将创建的线程要执行的操作声明在此方法中
 *3:currentThread():静态方法，返回当前代码的线程
 *4:getName:获取当前线程的名字
 *5:setName:设置当前线程名字
 *6:yield():释放当前cpu的执行权
 *7:join():线程a中使用join方法，代表线程a暂时终止等线程b先完成，线程a暂时处于堵塞状态
 *8:stop():当执行此方法时，强制结束当前线程
 *9:sleep(毫秒):让当前线程睡眠指定的时间毫秒，在指定的时间内，当前线程处于堵塞状态

 */
public class Demo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            setName("分线程");
            System.out.println(getName()+i);
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                if (i==50)
                join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
       Demo demo=new Demo();
       demo.start();
        for (int i = 0; i < 200; i++) {
            try {
                sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            currentThread().setName("主线程");
            System.out.println(currentThread().getName()+i);
            currentThread().stop();
//            if (i==3) {
//                try {
//                    demo.join();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
        }
    }
}

package JavaSenior.ThreadTest;

import com.sun.org.apache.xpath.internal.operations.Or;

import java.text.BreakIterator;

/**
 * 创建线程的两种方式
 *1：通过子类继承Thread类，重写run方法，创建对象调用start方法
 *2：通过实现类继承Runnable接口，去实现Runnable中的抽象run方法，创建实现类对象作为参数传入
 *  创建的Thread类对象中Thread thread=new Thread(实现类对象);进行调用start方法创建线程
 *
 *开发中优先选择Runnable接口方式创建
 * 原因：1：可以实现多继承，避免了类的单继承的缺点
 *      2：更适合用于多个线程共享数据的情况
 */
//方式1
public class Demo2 extends Thread {
    private  static int ticket=100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "\t" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
    public static void main(String[] args) {
        Demo2 demo2=new Demo2();
        Demo2 demo3=new Demo2();
        Demo2 demo4=new Demo2();
        demo2.setName("线程2");
        demo3.setName("线程3");
        demo4.setName("线程4");
        demo2.start();
        demo3.start();
        demo4.start();
    }
}

//方式2
class Demo3 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "\t" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }

    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
        Thread thread = new Thread(demo3);
        Thread thread1 = new Thread(demo3);
        Thread thread2 = new Thread(demo3);
        thread.setName("线程0");
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread.start();
        thread1.start();
        thread2.start();
    }
}
线程优先级：getPriority（）；获取线程优先级，setPriority（int p）：
设置线程优先级MAX==10.MIN==1,默认==5;