Java线程

目录

多线程

线程的生命周期图

创建线程有两种方式

方式一：继承Thread并重写run方法

方式二：实现Runnable接口单独定义线程任务

匿名内部类形式的线程创建

线程API 

线程优先级

sleep阻塞

守护线程 

多线程并发安全问题

synchronized关键字

同步方法

同步块

在静态方法上使用synchronized

互斥锁

总结

线程Thread类的常用方法

守护线程与普通线程的区别

多线程并发安全问题

synchronized的两种用法

同步监视器对象的选取

互斥性

---

多线程

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

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

        多线程改变了代码的执行方式，从原来的单一顺序执行流程变为多个执行流程"同时"执行。可以让多个代码片段的执行互不打扰。线程之间是并发执行的，并非真正意义上的同时运行。

        并发：

        多个线程实际运行是走走停停的。线程调度程序会将CPU运行时间划分为若给个时间片段并尽可能均匀的分配给每个线程，拿到时间片的线程被CPU执行这段时间。当超时后线程调度程序会再次分配一个时间片段给一个线程使得CPU执行它。如此反复。由于CPU执行时间在纳秒级别,我们感觉不到切换线程运行的过程。所以微观上走走停停，宏观上感觉一起运行的现象成为并发运行

        用途：

        当出现多个代码片段执行顺序有冲突时，希望它们各干各的时，就应当放在不同线程上“同时”运行。

        一个线程可以运行，但是多个线程可以更快时，可以使用多线程运行。

线程的生命周期图

创建线程有两种方式

方式一：继承Thread并重写run方法

        定义一个线程类,重写run方法,在其中定义线程要执行的任务(希望和其他线程并发执行的任务)

        注：启动线程要调用该线程的start方法，而不是run方法。

        优点：结构简单，便于匿名内部类形式创建。

        缺点：1.继承冲突：由于java单继承，导致如果继承了线程就无法再继承其他类去复用方法。

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

/**
 * 1:继承Thread并重写run方法
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建两个线程
        Thread t1 = new MyThread1();
        Thread t2 = new MyThread2();
        /*
            启动线程,注意:不要调用run方法！！
            线程调用完start方法后会纳入到系统的线程调度器程序中被统一管理。
            线程调度器会分配时间片段给线程，使得CPU执行该线程这段时间，用完后
            线程调度器会再分配一个时间片段给一个线程，如此反复，使得多个线程
            都有机会执行一会，做到走走停停，并发运行。
            线程第一次被分配到时间后会执行它的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接口单独定义线程任务

        优点：由于是实现接口，没有继承冲突问题。线程与任务没有耦合关系，便于线程的重用。

        缺点：创建复杂一些

/**
 * 实现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 t1 = new Thread(){
            public void run(){
                for(int i=0;i<1000;i++){
                    System.out.println("一只小狗！！");
                }
            }
        };
//        Runnable r2 = new Runnable() {
//            public void run() {
//                for(int i=0;i<1000;i++){
//                    System.out.println("汪汪汪汪~~~");
//                }
//            }
//        };
        //Runnable可以使用lambda表达式创建
        Runnable r2 = ()->{
                for(int i=0;i<1000;i++){
                    System.out.println("汪汪汪汪~~~");
                }
        };
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}

        java中的代码都是靠线程运行的，执行main方法的线程称为“主线程”。

        线程提供了一个方法：staticThread currentThread() 该方法可以获取运行这个方法的线程.

/**
 * java中所有的代码都是靠线程执行的，main方法也不例外。JVM启动后会创建一条线程来执行main
 * 方法，该线程的名字叫做"main",所以通常称它为"主线程"。
 * 我们自己定义的线程在不指定名字的情况下系统会分配一个名字，格式为"thread-x"(x是一个数)。
 */
public class CurrentThreadDemo {
    public static void main(String[] args) {
        /*
            很重要的API:ThreadLocal,它可以使得我们在一个线程上跨越多个
            方法时共享数据使用，其内部要用到currentThread方法来辨别线程。
            如spring的事务控制就是靠ThreadLocal实现的。
         */
        Thread main = Thread.currentThread();//获取执行main方法的线程(主线程)
        System.out.println("线程:"+main);
        dosome();//主线程执行dosome方法
    }
    public static void dosome(){
        Thread t = Thread.currentThread();//获取执行dosome方法的线程
        System.out.println("执行dosome方法的线程是:"+t);
    }
}

线程API 

        获取线程相关信息的方法

/**
 * 获取线程相关信息的一组方法
 */
public class ThreadInfoDemo {
    public static void main(String[] args) {
        Thread main = Thread.currentThread();//获取主线程

        String name = main.getName();//获取线程的名字
        System.out.println("名字:"+name);

        long id = main.getId();//获取该线程的唯一标识
        System.out.println("id:"+id);

        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);
    }
}

线程优先级

        线程start后会纳入到线程调度器中统一管理，线程只能被动的被分配时间片并发运行，而无法主动索取时间片，线程调度器尽可能均匀的将时间片分配给每个线程。

        线程有10个优先级，使用整数1-10表示

        1为最小优先级，10为最高优先级，5为默认值

        调整线程的优先级可以最大程度的干涉获取时间片的几率，优先级越高的线程获取时间片的次数越多，反之则越少。 

public class PriorityDemo {
    public static void main(String[] args) {
        Thread max = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("max");
                }
            }
        };
        Thread min = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("min");
                }
            }
        };
        Thread norm = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("nor");
                }
            }
        };
        min.setPriority(Thread.MIN_PRIORITY);
        max.setPriority(Thread.MAX_PRIORITY);
        min.start();
        norm.start();
        max.start();
    }
}

sleep阻塞

        线程提供了一个静态方法：static void sleep(long ms)

        使运行该方法的线程进入阻塞状态指定的毫秒,超时后线程会自动回到RUNNABLE状态等待再次获取时间片并并发运行。

public class SleepDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了!");
        try {
            Thread.sleep(5000);//主线程阻塞5秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("程序结束了!");
    }
}

        sleep方法处理异常：InterruptedException. 

        当一个线程调用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(9999999);
                } catch (InterruptedException e) {
                    System.out.println("青雉:要疯了!");
                }
                System.out.println("青雉:睡醒了，真不错");
            }
        };

        Thread hun = new Thread(){
            public void run(){
                System.out.println("黄猿:呼呼呼呼路!");
                for(int i=0;i<5;i++){
                    System.out.println("黄猿:卖糖葫芦咯!买糖葫芦咯!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                    }
                }
                System.out.println("哦豁!");
                System.out.println("黄猿:糖葫芦没有咯!");
                lin.interrupt();//中断lin的睡眠阻塞
            }
        };
        lin.start();
        hun.start();
    }
}

守护线程 

        守护线程也称为：后台线程

        守护线程是通过普通线程调用setDaemon(boolean on)方法设置而来的，因此创建上与普通线程无异。

        守护线程的结束时机上有一点与普通线程不同，即：进程的结束。

        进程结束：当一个进程中的所有普通线程都结束时，进程就会结束，此时会杀掉所有正在运行的守护线程。

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) {
                    }
                }
                System.out.println("rose:啊啊啊啊啊啊AAAAAAAaaaaa....");
                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) {
                    }
                }
            }
        };
        rose.start();
        jack.setDaemon(true);//设置守护线程必须在线程启动前进行
        jack.start();
    }
}

        通常当我们不关心某个线程的任务什么时候停下来，它可以一直运行，但是程序主要的工作都结束时它应当跟着结束，这样的任务就适合放在守护线程上执行，比如GC就是在守护线程上运行的。

多线程并发安全问题

        当多个线程并发操作同一临界资源，由于线程切换实际不确定，导致操作临界资源的顺序出现混乱严重时可能导致系统瘫痪。

        临界资源：操作该资源的全过程，同时只能被单个线程完成

public class SyncDemo {
    public static void main(String[] args) {
        Table table = new Table();
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    /*
                        static void yield()
                        线程提供的这个静态方法作用是让执行该方法的线程
                        主动放弃本次时间片。
                        这里使用它的目的是模拟执行到这里CPU没有时间了，发生
                        线程切换，来看并发安全问题的产生。
                     */
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        t1.start();
        t2.start();
    }
}

class Table{
    private int beans = 20;//桌子上有20个豆子
    public int getBean(){
        if(beans==0){
            throw new RuntimeException("没有豆子了!");
        }
        Thread.yield();
        return beans--;
    }
}

synchronized关键字

synchronized有两种使用方式:

        1.在方法上修饰，此时该方法变为一个同步方法

        2.同步块，可以更准确的锁定需要排队的代码块段

同步方法

        当一个方法使用synchronized修饰后，这个方法称为“同步方法”，即：多个线程不能同时在方法内部执行，只能有先后顺序的一个一个进行，将并发操作同一临界资源的过程改为同步执行就可以有效的解决并发安全问题。

public class SyncDemo {
    public static void main(String[] args) {
        Table table = new Table();
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        t1.start();
        t2.start();
    }
}

class Table{
    private int beans = 20;//桌子上有20个豆子
    /**
     * 当一个方法使用synchronized修饰后，这个方法称为同步方法，多个线程不能
     * 同时执行该方法。
     * 相当于让多个线程从原来的抢着操作改为排队操作。
     */
    public synchronized int getBean(){
        if(beans==0){
            throw new RuntimeException("没有豆子了!");
        }
        Thread.yield();
        return beans--;
    }
}

同步块

        有效的缩小同步范围可以在保证并发安全的前提下尽可能的提高并发效率，同步块可以更准确的锁定需要多个线程同步执行的代码片段来有效缩小排队范围。

语法：

        synchronized(同步监视器对象){
           需要多线程同步执行的代码片段
        }

        同步监视器对象即上锁的对象，要保证同步块中代码被多个线程同步运行，则要求多个线程看到的同步监视器对象时同一个。

public class SyncDemo2 {
    public static void main(String[] args) {
        Shop shop = new Shop();
        Thread t1 = new Thread(){
            public void run(){
                shop.buy();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                shop.buy();
            }
        };
        t1.start();
        t2.start();
    }
}

class Shop{
    public void buy(){
        /*
            在方法上使用synchronized，那么同步监视器对象就是this。
         */
//    public synchronized void buy(){
        Thread t = Thread.currentThread();//获取运行该方法的线程
        try {
            System.out.println(t.getName()+":正在挑衣服...");
            Thread.sleep(5000);
            /*
                使用同步块需要指定同步监视器对象，即:上锁的对象
                这个对象可以是java中任何引用类型的实例，只要保证多个需要排队
                执行该同步块中代码的线程看到的该对象是"同一个"即可
             */
            synchronized (this) {
//            synchronized (new Object()) {//没有效果!
                System.out.println(t.getName() + ":正在试衣服...");
                Thread.sleep(5000);
            }

            System.out.println(t.getName()+":结账离开");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

在静态方法上使用synchronized

        当在静态方法上使用synchronized后，该方法是一个同步方法，由于静态方法属于类，所有一定具有同步效果。 

        静态方法使用的同步监视器对象为当前类的类对象(Class的实例)。

public class SyncDemo3 {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            public void run(){
                Boo.dosome();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                Boo.dosome();
            }
        };
        t1.start();
        t2.start();
    }
}
class Boo{
    /**
     * synchronized在静态方法上使用是，指定的同步监视器对象为当前类的类对象。
     * 即:Class实例。
     * 在JVM中，每个被加载的类都有且只有一个Class的实例与之对应
     */
    public synchronized static void dosome(){
            Thread t = Thread.currentThread();
            try {
                System.out.println(t.getName() + ":正在执行dosome方法...");
                Thread.sleep(5000);
                System.out.println(t.getName() + ":执行dosome方法完毕!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

        静态方法中使用同步块时，指定的所对象通常也是当前类的类对象 

class Boo{
    public static void dosome(){
        /*
            静态方法中使用同步块时，指定同步监视器对象通常还是用当前类的类对象
            获取方式为:类名.class
         */
        synchronized (Boo.class) {
            Thread t = Thread.currentThread();
            try {
                System.out.println(t.getName() + ":正在执行dosome方法...");
                Thread.sleep(5000);
                System.out.println(t.getName() + ":执行dosome方法完毕!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

互斥锁

        当多个线程执行不同的代码片段，但是这些代码片段之间不能同时运行时就要设置为互斥的.

        使用synchronized锁定多个代码片段，并且指定的同步监视器是同一个时，这些代码片段之间就是互斥的。即：多个线程不能同时访问这些方法

public class SyncDemo4 {
    public static void main(String[] args) {
        Foo foo = new Foo();
        Thread t1 = new Thread(){
            public void run(){
                foo.methodA();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                foo.methodB();
            }
        };
        t1.start();
        t2.start();
    }
}
class Foo{
    public synchronized void methodA(){
        Thread t = Thread.currentThread();
        try {
            System.out.println(t.getName()+":正在执行A方法...");
            Thread.sleep(5000);
            System.out.println(t.getName()+":执行A方法完毕!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void methodB(){
        Thread t = Thread.currentThread();
        try {
            System.out.println(t.getName()+":正在执行B方法...");
            Thread.sleep(5000);
            System.out.println(t.getName()+":执行B方法完毕!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

总结

        线程的创建方式

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

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

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

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

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

        优点：犹豫是实现接口，没有继承冲突问题

                   线程与任务没有耦合关系，便于线程的重用

        缺点：创建复杂一些

线程Thread类的常用方法

        void run()：线程本身有run方法，可以在第一种创建线程时重写该方法来定义线程任务。

        void start()：启动线程的方法，调用后线程被纳入到线程调度器中统一管理，并处于RUNNABLE状态，等待分配分配时间片开始并发运行。

注:线程第一次获取时间片开始执行时会自动执行run方法。

**启动线程一定是调用start方法，而不能调用run方法!**

        String getName()：获取线程名字

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

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

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

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

        boolean isInterrupted()：是否被中断了

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

优先级越高的线程获取时间片的次数越多。可以使用Thread的常量MIN_PRIORITY,NORM_PRIORITY,MAX_PRIORITY。他们分别表示                                                最低，               默认，           最高优先级

        static void sleep(long ms):静态方法sleep可以让运行该方法的线程阻塞参数ms指定的毫秒.

        static Thread currentThread()：获取运行该方法的线程。

守护线程与普通线程的区别

        守护线程是普通线程调用setDaemon(true)设置而来的。

        主要区别体现在当java进程中所有的普通线程都结束时进程会结束，在结束前会杀死所有还在运行的守护线程。

多线程并发安全问题

什么是多线程并发安全问题：

        当多个线程并发操作同一临界资源，由于线程切换时机不确定，导致执行顺序出现混乱。

        解决方法：将并发操作改为同步操作就可有效的解决多线程并发安全问题

同步与异步的概念：

        同步和异步都是说的多线程的执行方式，多线程各自执行各自的就是异步执行，而多线程执行出现了先后顺序进行就是同步执行。

synchronized的两种用法

        1.直接在方法上声明，此时该方法称为同步方法，同步方法同时只能被一个线程执行。

        2.同步块，推荐使用。同步块可以更准确的控制需要同步执行的代码片段。

有效的缩小同步范围可以在保证并发安全的前提下提升并发效率

同步监视器对象的选取

        对于同步的成员方法而言，同步监视器对象不可指定，只能是this

        对于同步的静态方法而言，同步监视器对象也不可指定，只能是类对象

        对于同步块而言，需要自行指定同步监视器对象，选取原则：

                1.必须是引用类型

                2.多个需要同步执行该同步块的线程看到的该对象必须是同一个

互斥性

        当使用多个synchronized修饰了多个代码，并且指定的同步监视器都是同一个对象时，这些代码片段就是互斥的，多个线程不能同时在这些代码片段上执行。