Java语法基础学习DaySixteen（多线程）

一、多线程的创建

1.作用

　　程序需要同时执行两个或多个任务时需要多线程。

　　程序需要实现需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等，需要多线程。

　　需要一些后台运行的程序时，需要多线程。

2.实现

　　Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread来实现。

　　Thread类的特性：

　　　　每个线程都是通过某个特定Thread对象的run()方法来完成操作的。经常把run()方法的主体称为线程体。

　　　　通过Thread对象的start()方法来启动这个线程。

3.创建多线程的第一种方法：继承java.lang.Thread类

　　代码案例

　　创建一个子线程，完成1-100的自然数的输出，主线程也做同样操作。

//1.创建一个继承thread的子类
class SubThread extends Thread{
    //2.重写run()方法，方法体实现子线程要完成的功能
    @Override
    public void run(){
        for(int i = ;i <= ;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            //输出结果：Thread-0:1...,和主线程的输出结果交错出现。
        }
    }
}

public class Test{
    public static void main(String[] args){
        //3.创建一个子类的对象，一个对象对应一个子线程
        SubThread st = new SubThread();

        //4.调用线程的start()方法，启动此线程，将自动调用run()方法
        //一个线程只能执行一次start()
        //不能通过run()方法去启动一个线程，即st.run()。
        st.start();

        for(int i = ;i <= ;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            //输出结果：main:1...
        }
    }

}

4.Thread的常用方法

start()：启动线程并执行相应的run()方法

run()：子线程要执行的代码放入到run()方法中

currentThread()：静态的，调取当前的线程

getName()：获取此线程的名字

setName()：设置此线程的名字

yield()：调用此方法的线程释放当前CPU的执行权

join()：在A线程中调用B线程的join()方法：A线程停止执行，直到B线程执行完毕，A线程再接着join()之后的代码执行

isAlive()：判断当前线程是否存活

sleep(long l)：显式的让当前线程睡眠 l 毫秒

线程通信：wait()　　notify()　　notifyAll()　　日后再表

getPriority()：返回线程优先级，优先级从1到10十个档次，默认为5.（优先级只是抢到CPU的概率的大小区别，并不是优先级大的线程就一定先完成。）

setPriority(int newPriority)：改变线程的优先级

class SubThread extends Thread{
    @Override
    public void run(){
        for(int i = ;i <= ;i++){

            //注意这里的异常处理只能是try-catch，不能throws，因为不能比父类Thread的run()方法抛出更大的异常。
            try{
                Thread.currentThread().sleep();//睡眠0.1秒
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            //输出结果：子线程:10:1  ...
            System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);

        }
    }
}

public class Test{
    public static void main(String[] args){

        SubThread st = new SubThread();
        st.setName("子线程");
        //设置优先级(MIN_PRIORITY = 1 NORM_PRIORITY = 5 MAX_PRIORITY = 10)
        st.setPriority(Thread.MAX_PRIORITY);
        st.start();
        Thread.currentThread().setName("---主线程");
        for(int i = ;i <= ;i++){
            //输出结果：---主线程:5:1  ... 默认优先级为5
            System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
            //如果i是10的整数倍，主线程调用yield，释放CPU执行权，但有可能又被主线程抢回CPU,继续执行主线程
            //if(i % 10 == 0){
            //    Thread.currentThread().yield();
            //}

            //如果i等于20，停止主线程的执行，直到子线程执行完毕再继续执行之后的代码。
            if(i == ){
                try{
                    st.join();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }

            }
        }
        System.out.println(st.isAlive());//输出false,子进程死亡；输出true，子线程存活，比主进程慢完成
    }

}

5.继承方式实现多窗口售票

class Window extends Thread{
    static int ticket = ;
    public void run(){
        while(true){
            if(ticket > ){
                System.out.println(Thread.currentThread().getName()+"售票，票号为：" + ticket--);
            }else{
                break;
            }
        }
    }
}

public class Test{
    public static void main(String[] args){
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("售票口1");
        w2.setName("售票口2");
        w3.setName("售票口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

6.创建多进程的第二种方法：实现Runnable接口

优点（相对于继承Thread类）

　　避免了Java单继承的局限性。

　　如果多个线程操作同一份资源，更适合使用实现的方式（详见售票口案例的比较）

代码案例

//1.创建一个实现了Runnable接口的类
class PrintNum implements Runnable{
    //2.实现接口的抽象方法run()
    public void run(){
        for(int i = ;i <= ;i++){
            if(i %  == )
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class Test{
    public static void main(String[] args){
        //3.创建一个Runnable接口实现类的对象
        PrintNum p = new PrintNum();
        //4.将此对象作为形参传给Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(p);
        t1.start();//启动线程，执行Thread对象生成时构造器形参的对象的run()方法
    }
}

7.实现方式实现多窗口售票

class Window implements Runnable{
    int ticket = ;//注意不用static了，因为只需要创建一个对象
    public void run(){
        while(true){
            if(ticket > ){
                System.out.println(Thread.currentThread().getName()+"售票，票号为：" + ticket--);
            }else{
                break;
            }
        }
    }
}

public class Test{
    public static void main(String[] args){
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("售票口1");
        t2.setName("售票口2");
        t3.setName("售票口3");

        t1.start();
        t2.start();
        t3.start();
    }
}