多线程的演示

多线程（一个class中）

---

多线程可以并发执行多个代码片段
并发:多个线程宏观上是一起执行,微观上是走走停停的.
第一种创建线程的方式:
1:继承Thread
 2:重写run方法

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread1();
        Thread t2 = new MyThread2();
        t1.start();
        t2.start();
    }
}

继承线程并重写run方法的形式优点在于结构简单,利于使用匿名内部类形式创建.
缺点主要有两个:
1:由于java是单继承的,导致如果继承了Thread就不能再继承其它类了,这在实际开发时非常不方便.
2:在定义线程同时重写run方法来定义任务,这导致线程与任务存在必然的耦合关系,不利于线程的重用.

class MyThread1 extends Thread{
    @Override
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("你谁啊");
        }
    }

}
class MyThread2 extends Thread{
    @Override
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("看热闹的");
        }
    }

}

第二种创建线程的方法

---

实现Runnable接口单独定义线程任务.

public class ThreadDemo2 {
    public static void main(String[] args) {
        /*
        实例化任务
         */
        Runnable r1= new MyRunnable1();
        Runnable r2= new MyRunnable2();
        /*
        创建线程
         */
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}
class MyRunnable1 implements Runnable {
    @Override
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("?");
        }
    }

}
class MyRunnable2 implements Runnable {
    @Override
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("看热闹的");
        }
    }

}

使用匿名内部类形式创建线程

---

public class ThreadDemo3 {
    public static void main(String[] args) {
        /*
        方式一继承Tread重写run方法
         */
        Thread t1 = new MyThead11();

        /*
        方法2：实现runnable接口单独定义任务
         */
        Runnable r2 = ()->{
            for (int i=0;i<1000;i++){
                System.out.println("15");
            }
        };
        Thread t2 =new Thread(r2);
        t1.start();
        t2.start();
    }

}

class MyThead11 extends Thread{
    @Override
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("你谁啊");
        }
    }
}

获取线程相关信息的一组方法

---

        获取主线程

        Thread t = Thread.currentThread();
        String name =t.getName();
        System.out.println("name:"+name);

        获取唯一标识

        long id = t.getId();
        System.out.println("id:"+id);

        获取线程优先级 1-10，默认为5

        int priority = t.getPriority();
        System.out.println("优先级:"+priority);

        线程是否活着

        boolean isAlive = t.isAlive();
        System.out.println("isAlive:"+isAlive);

        是否为守护线程

        boolean isDaemon = t.isDaemon();
        System.out.println("isDaemon:"+isDaemon);

        是否被中断了

        boolean isInterrupted = t.isInterrupted();
        System.out.println("isInterrupted:"+isInterrupted);

  static Thread currentThread()

---

线程提供了一个静态方法：
 static Thread currentThread()
该方法可以获取运行这个方法的线程
java中所有的代码都是靠线程执行的，main方法也不例外，运行main方法的线程是JVM创建的，并且取名为“main"
我们称它为主线程

public class CurrentThreadDemo {
    public static void main(String[] args) {
        Thread main = Thread.currentThread();
        System.out.println("主线程："+main);
        dosome();
    }
    public static void dosome(){
        Thread t = Thread.currentThread();
        System.out.println("运行dosome方法的线程："+t);

    }

}

线程的优先级

---

线程有10个优先级，分别用整数1-10表示。其中1为最低，5为默认，10为最高优先级。
当线程调用start方法后就纳入到了线程调度器中被统一管理，此时只能被动的被分配时间片并发运行。线程不能主动索取时间片。通过调整线程的优先级可以最大程度的调节获取时间片的概率。
 线程优先级越高的线程获取时间片的次数越多。
 

public class PriorityDemo {
    public static void main(String[] args) {
        Thread min = new Thread(){
            @Override
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("min");
                }
            }
        };
        Thread norm = new Thread(){
            @Override
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("nor");
                }
            }
        };
        Thread max = new Thread(){
            @Override
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("max");
                }
            }
        };
//        min.setPriority(1);
        /*
        设置为最小优先级
         */
        min.setPriority(Thread.MIN_PRIORITY);
        /*
        设置为最高优先级
         */
        max.setPriority(Thread.MAX_PRIORITY);

        min.start();
        norm.start();
        max.start();
    }
}