【使用JAVA实现并发编程——多线程】

简介:不同语言实现并发编程的方式存在不同,在Java标准库中,就提供了一个Thread类来表示线程！

一.Thread类的基本用法

1.创建线程的写法:

①.创建子类,继承自Thread.重写Thread类中的run()方法,在new的时候newThread的子类,在run()中写在县城中具体实现的代码,描述了这个线程内部要执行哪些代码.在代码中,并非定义了子类,一写run方法,线程就创建出来,线程的具体实现,需要调用start方法,线程才被创建出来。调用start之前,系统中并没有创建出线程。

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

 如果在一个循环中不加任何限制,这个循环的速度非常非常快,在线程中可以加上一个sleep操作,来强制让这个线程休眠一段时间,这个休眠操作,就是强制让线程进入阻塞状态,单位是ms,相当于一秒之内这个线程不会到cpu上执行

class MyThread1 extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 一个进程中至少会有一个线程.在一个java进程中,也是至少会有一个调用main方法的线程(系统自生成),,此时t线程和main线程,就是并发执行的关系(此处的并发=并行+并发),现在两个线程都是打印一条休眠一秒,当一秒时间到了之后.系统先唤醒哪个线程的顺序是随机的.对于操作系统来说,内部对于线程之间的调度顺序,在宏观上也可以认为是随机的~~~(抢占式执行)

class MyThread1 extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Thread t = new MyThread1();
        t.start();
        
        while (true){
            System.out.println("hello world");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

②.创建一个类,实现Runnable接口,再创建Runnable实例传给Thread

Runnable就是在描述一个"任务",通过Runnable来描述一个任务,进一步的再把描述好的任务交给Thread实例

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

 ③.写法三/写法四:就是上述两个写法的翻版,使用了匿名内部类,继承自Thread类,同时重写run方法,同时在new出这个匿名内部类的实例

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(){//匿名内部类
            @Override
            public void run(){
                System.out.println("hello thread");
            }
        };
        t.start();
    }
}

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello thread!");
            }
        });
        t.start();
    }
}

new的Runnable,针对这个创建的匿名内部类,同时new出的Runnable实例传给Thread的构造方法 

 

④.第五种写法是第四种写法的延伸,使用lambda表达式(使用lambda代替了Runnable而已~~)

public class Demo6 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            System.out.println("hello thread");
        });
        t.start();
    }
}

 2、Thread类的其他属性和方法

①.是否后台线程（isDaemon）

*具体代码案例参考Demo7

如果线程是后台线程，就不影响进程退出；如果线程不是后台线程（前台线程），就会影响到进程退出。创建的t1和t2默认都是前台的线程，即使main方法执行完毕，进程也不能退出，得等t1和t2都执行完，整个进程才能退出；如果t1和t2是后台线程，此时如果main执行完毕，整个进程就直接退出，t1和t2就被强行终止了~~

②.给线程（thread对象）起一个名字

Thread（String name）

 仅仅只是影响程序猿调试，可以借助一些工具看到每个线程以及名字，很容易在调试中对线程做出区分~~~

public class Demo8 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() ->{
            while (true){
                System.out.println("hello thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"ThreadT1");
        t1.start();
        Thread t2 = new Thread(() ->{
            while (true){
                System.out.println("hello thread2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"ThreadT2");
        t2.start();
    }
}

 ③.线程是否存活（isAlive），操作系统中对应的线程是否正在运行

Thread t对象的生命周期和内核中对应的线程，生命周期并不完全一致~~

创建出t对象之后，在调用start之前，系统中是没有对应线程的~~

在run方法执行完毕之后，系统中的线程就销毁了，但是t这个对象可能还存在~~

通过isAlive就能判定当前系统的线程的运行情况

如果调用start之后，run执行完之前，isAlive就返回True；

如果调用start之前，run执行完之后，isAlive就返回False。

3、Thread中的一些重要方法

①.start（决定了系统是不是真的创建出线程）

t.run()； ---> run单纯的只是一个普通的方法，描述了任务的内容

              run方法只是一个普通的方法，在main线程里调用run，并没有创建新的线程

t.start(); --->start则是一个特殊的方法，内部会在系统中创建线程

②.中断线程~~让一个线程停下来~~

线程停下来的关键，是要让线程对应的run方法执行完~~（还有一个特殊的，是main这个线程，对于main来说，得是main方法执行完，线程就完了）

（一）、可以手动的设置一个标志位，来控制线程是否要执行结束~~~

public class Demo9 {
    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!isQuit){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        //只要把isQuit设为True,此时这个循环就退出了,进一步的run就执行完了,再进一步就是线程执行结束了
        try {
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
 //main线程在此时执行isQuit = true的操作，此时t线程的while循环条件不成立，那么t线程就终止了
        isQuit = true;
        System.out.println("终止T线程");
    }
}

 （二）、更好的做法，使用Thread中内置的一个标志位来进行判定~~

可以通过：Thread.interrupted() 这是一个静态的方法；Thread.currentThread().isInterrupted() 这是实例方法，其中currentThread能够获取到当前线程的实例。

public class Demo10 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //在主线程中，调用interrupted方法，来中断这个线程
        //t.interrupt的意思就是t线程被中断！！！
        t.interrupt();
    }
}

 t.interrupt();调用这个方法，可能产生两种情况：①.如果t线程是处在就绪状态，就是设置线程的标志位为true；②.如果t线程处在阻塞状态（sleep休眠了），就会触发一个InterruptException~~

 此处的中断，是希望能够立即产生效果的~~如果线程以及是阻塞状态下，此时设置标志位就不能起到及时唤醒的效果~~

调用这个interrupt方法，就会让sleep触发一个异常，从而导致线程从阻塞状态被唤醒~当下的代码一旦触发了异常之后，就会进入了catch语句，在catch语句中，就单纯的只是打了一个日志。

            while (!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //当触发异常的时候，立即就退出循环
                    break;
                }
            }

 Thread.interrupted() 这个方法判定的标志位是Thread的static成员（一个程序中只有一个标志位）。

Thread.currentThread().isinterrupted()这个方法判定的标志位是Thread的普通成员，每个实例都有自己的标志位。

③. 线程等待

多个线程之间的调度顺序不确定的~~

线程等待就是一种控制线程执行顺序的手段~~此处的线程等待，主要是控制线程结束的先后顺序~
join~

调用join的时候，哪个线程调用的join，哪个线程就会阻塞等待~~得到对应的线程执行完毕为止（对应线程的run执行完）

通过线程等待，就是在控制让t先结束，main后结束

public class Demo11 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        //在主线程中就可以使用一个等待操作，等待t线程执行结束
        try {
            t.join();//首先，调用这个方法的线程是main线程，针对t这个线程对象调用的，此时就是让main等待t~~~~
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //调用join之后，main线程就会进入阻塞状态（暂时无法再cpu上执行）
        //等t线程执行完之后，才会执行下面的main线程中的代码
        System.out.println("t执行完了，main才执行");
    }
}

 join操作默认情况下，是死等（不合理），join提供了另外一个版本，就是可以执行等待时间，最常等待时间，如果等不到，就不等了去执行要执行的代码。

public class Demo12 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        try {
            t.join(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("等不及了，不等了");
    }
}

 ④.获取当前线程的引用

Thread.currentThread()就能够获取到当前线程的引用；哪个线程调用的这个currentThread，就获取到的哪个线程的实例~~~

public class Demo13 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        t.start();
        
        //这个操作是在main线程中使用，拿到的就是main这个线程的实例
        System.out.println(Thread.currentThread().getName());
    }
}

 ⑤.线程休眠

sleep~~~

如果一个进程有多个线程，此时每个线程都有一个PCB，一个进程对应的就是一组PCB了~~

PCB上有一个字段tgroupid，这个id其实就相当于进程的id，同一个进程中的若干个线程的tgroupid是相同的！！！

如果某个线程调用了sleep方法，这个PCB就会进入到阻塞队列~~

操作系统调度线程的时候，就只是从就绪队列中挑选合适的PCB到CPU上运行，阻塞队列里的PCB就只能干等着~~

当睡眠时间到了，系统就会把刚才这个PCB从阻塞队列挪回就绪队列（休眠结束）

二.多线程能够提高任务完成的效率

public class Demo7 {
    private static final long count = 10_0000_0000;
    public static void serial(){
        //记录程序执行时间
        long begin = System.currentTimeMillis();
        long a = 0;
        for (int i = 0; i < count; i++) {
            a++;
        }
        long b = 0;
        for (int i = 0; i < count; i++) {
            b++;
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("串行消耗的时间:" + (end - begin) + "ms");
    }

    public static void concurrency() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread t1 = new Thread(() ->{
            long a = 0;
            for (int i = 0; i < count; i++) {
                a++;
            }
        });
        t1.start();
        Thread t2 = new Thread(() ->{
            long b = 0;
            for (int i = 0; i < count; i++) {
                b++;
            }
        });
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println("并行消耗的时间:"+ (end - start)+"ms");
    }
    public static void main(String[] args) throws InterruptedException {
        serial();
        concurrency();
    }
}

serial代表串行执行，concurrency代表了多线程并行执行。

并发执行相比于串行执行效率提升了将近50%。

main和t1、t2是并发执行的关系，此处t1和t2还没执行完呢，这里就开始记录结束时间了。因此，main线程需要等待t1、t2执行完毕后再记录结束时间。使用t1.join和t2.join，join效果就是等待线程结束，t1.join就是让main线程等待t1执行结束，t2.join让main线程等待t2结束。

创建线程本身也会消耗时间，当数据量小时，串行执行效率就会高于并发执行！