JAVASE------并发、线程及相关方法

1、线程：

1）线程的常用方法

>String getName()：获取线程名字

>long getId()：获取线程唯一标识

>int getPriority()：获取线程优先级，对应的是整数1-10

>boolean isAlive()：线程是否还活着

>boolean isDaemon()：是否为守护线程

>boolean isInterrupted()：是否被中断了

>currentThread()：获取运行该方法的线程

>void setPriority(int priority)：设置线程优先级，参数可以传入整数1-10。1为最低优先级，5为默认优先级，10为最高优先级

public class ThreadInfoDemo {
    public static void main(String[] args) {
        //获取主线程
        Thread main = Thread.currentThread();
        //获取线程的名字
        String name = main.getName();
        System.out.println("name:"+name);
        //获取唯一标识
        long id = main.getId();
        System.out.println("id:"+id);
        //获取线程的优先级，默认值为5.整数范围:1-10
        int priority = main.getPriority();
        System.out.println("优先级:"+priority);
        //线程是否活着
        boolean isAlive = main.isAlive();
        System.out.println("是否活着:"+isAlive);
        //是否为守护线程
        boolean isDaemon = main.isDaemon();
        System.out.println("是否为守护线程:"+isDaemon);
        //是否被中断
        boolean isInterrupted = main.isInterrupted();
        System.out.println("是否被中断:"+isInterrupted);

    }
}

public class CurrentThreadDemo {
    public static void main(String[] args) {
        //获取执行main方法的线程
        Thread main = Thread.currentThread();//获取运行该方法的线程
        System.out.println("主线程:"+main);
        dosome();
        System.out.println(main+"线程执行完毕了");
    }

    public static void dosome(){
        //获取执行dosome方法的线程
        Thread t = Thread.currentThread();
        System.out.println("执行dosome方法的线程是:"+t);
    }
}

2）线程与多线程：

>线程：单一的顺序执行流程就是一个线程，顺序执行:代码一句一句的先后执行；

>多线程：多个线程并发执行。线程之间的代码是快速被CPU切换执行的，造成一种感官上"同时"执行的效果。

3）线程的创建方式：

①继承Thread，重写run方法，在run方法中定义线程要执行的任务

>优点:

结构简单，便于匿名内部类创建

>缺点:

继承冲突:由于java单继承，导致如果继承了线程就无法再继承其他类去复用方法；

耦合问题:线程与任务耦合在一起，不利于线程的重用。

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread1();
        Thread t2 = new MyThread2();
        /*
            启动线程要调用start方法，而不是直接调用run方法!!!
         */
        t1.start();
        t2.start();
    }
}

class MyThread1 extends Thread{
    public void run(){
        for(int i=0;i<1000;i++){
            System.out.println("你是谁啊？");
        }
    }
}
class MyThread2 extends Thread{
    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{
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("你是谁啊?");
        }
    }
}
class MyRunnable2 implements Runnable{
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("我是查水表的!");
        }
    }
}

③匿名内部类方式创建线程：

/**
 * 以匿名内部类形式完成两种线程的创建方式
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //直接继承Thread并重写run方法形式
        Thread t1 = new Thread(){
            public void run(){
                String name = getName();//获取t1线程的名字
                System.out.println(name);
                for(int i=0;i<1000;i++){
                    System.out.println("你是谁啊？");
                }
            }
        };

 /*       实现Runnable接口重写run方法形式
        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<1000;i++){
                    System.out.println("我是查水表的!");
                }
            }
        };
        Thread t2 = new Thread(r2);
        
  */

        //lambda表达式写法
        Thread t2 = new Thread(()->{
            for (int i=0;i<1000;i++){
                System.out.println("我是查水表的!");
            }
        });

        t1.start();
        t2.start();


    }
}

4）线程优先级的调整：

>方法：setPriority(int priority)

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

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

    }
}

5）守护线程：

>进程中所有的用户线程都结束时，进程就会结束，此时会强制杀死所有还在运行的守护线程。

>方法：setDaemon(true)

/**
 * 守护线程
 * 我们正常创建的线程默认都是用户线程，当调用线程方法setDaemon(true)时可以
 * 将一个线程设置为守护线程。
 * 守护线程和用户线程唯一的区别是当进程结束
 * 一个进程中所有的用户线程都结束时，进程就会结束，此时会强制杀死所有还在运行的
 * 守护线程。
 *
 */
public class DaemonThreadDemo {
    public static void main(String[] args) {
        Thread rose = new Thread(){
            public void run(){
                for(int i=0;i<5;i++){
                    System.out.println("rose:let me go!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("rose:啊啊啊啊啊啊AAAAAaaaaa...");
                System.out.println("噗通");
            }
        };

        Thread jack = new Thread(){
            public void run(){
                while(true){
                    System.out.println("jack:you jump!i jump!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        rose.start();
        //设置守护线程必须在线程启动前进行!
        jack.setDaemon(true);//设置为守护线程
        jack.start();

//        while(true);//若主线程不结束，进程不会结束，那么jack也不会被强制杀死
    }
}

6）利用线程阻塞，创建线程定时程序：倒计时程序

>方法：static void sleep(long ms)

public class SleepDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        /*
            简易的倒计时程序。
            程序启动后在控制台上输入一个数字，从该数字开始每秒递减，到0时
            输出时间到
         */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字:");
        for(int num = scanner.nextInt();num>0;num--) {
            System.out.println(num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序结束了");
    }
}

7）interrupt()：终端线程阻塞

>当一个线程调用sleep方法处于睡眠阻塞的过程中，该线程的interrupt方法被调用那么该线程会在sleep方法这里立即抛出中断异常并停止睡眠阻塞。

public class SleepDemo2 {
    public static void main(String[] args) {
        Thread lin = new Thread(){
            public void run(){
                System.out.println("林:刚美完容，睡一会吧~");
                try {
                    Thread.sleep(500000000);
                } catch (InterruptedException e) {
                    System.out.println("林:干嘛呢!干嘛呢!干嘛呢!都破了相了!");
                }
                System.out.println("林:醒了");
            }
        };

        Thread huang = new Thread(){
            public void run(){
                System.out.println("黄:大锤80！小锤40！开始砸墙！");
                for(int i=0;i<5;i++){
                    System.out.println("黄:80！");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("咣当!");
                System.out.println("黄:大哥，搞定！");
                //中断lin的睡眠阻塞
                lin.interrupt();
            }
        };

        lin.start();
        huang.start();
    }
}