Java多线程(初阶)(上)

目录

​

认识线程

线程是什么

为什么要有线程

Java中执行多线程编程

线程的创建

多线程运行

run()方法与start()方法的区别

多线程的优势

 多线程的缺点

线程中断

线程等待

线程休眠

多线程带来的风险--线程安全

线程的状态

线程安全

 线程不安全的原因

---

认识线程

线程是什么

什么是线程,一个线程就是一个"执行流",如果说一个进程是一整个函数,那么线程就是这个函数内的一段代码,每个线程之间都可以按照顺序执行自己的代码,多个线程之间同时执行着多份代码.

举个例子:

假设一家公司要去银行办理业务 ,这个办理业务就是一个进程.

如果办理的业务既要进行财务转账,又要进行福利发放,还要进行缴纳社保,这三件事是为了完成这个业务,所以每一件事都是一个线程.

如果只有张三一个会计肯定忙不过来(主要是排队慢),为了让这个业务快速完成,张三就找来了李四和王五两位同事一同去银行处理业务,三个人分别负责一个事,分别申请一个号码去排队,自此就有了三个执行流共同完成任务,此时我们就把这种情况称为多线程.

为什么要有线程

进程包含线程,再知道为什么要有线程前,我们先要明白为啥要有进程?

那为什么要有进程呢?

因为我们的系统支持多任务了~~程序猿也就需要"并发编程"~~

回顾进程的两个基本属性:

①进程是一个可以拥有资源的独立单位

②进程是一个可以独立调度和分派的基本单位

注:

②中的进程指只有一个线程的进程,我们前面所说的进程调度,更严谨的说是线程的调度,当时我们举的时间管理大师的例子,相当于每个进程只有一个线程

正是因为这两个属性,通过多进程是可以实现"并发编程"的~

 虽然多进程可以实现并发编程,但是有点小问题:

①创建进程.系统在创建进程时,必须为其分配其所必需的所有资源~

②销毁进程:在销毁进程时,又必须得对进程的资源进行回收~

③进程状态转换:在进程创建之后到销毁之前,要经历若干次的状态转换,在进行状态转换时,要保留进程执行时的cpu环境,并设置新选中进程的cpu环境~

如果需要频繁的创建销毁,所需成本是比较高的,因为对于资源的申请和释放本来就是一个比较低效的操作~

那么如何解决这些问题?

两种思路:

 

举个例子:

那是不是线程越多越好呢?

当然不是,想想一个工厂里只有一台原料机,空间只有那么大,生产线多起来时,原料不够,还是需要等待,当多个线程竞争同一资源时,整体的速度就慢了下来.就像我们的电脑~~整体的硬件资源时有限的~~

Java中执行多线程编程

线程的创建

在Java标准库中,就提供了一个Thread类,来表示和操作线程.

每个Thread类对象都是一个线程~

那么如何创建线程呢?

共有5中方式,逐一示范:

方法①:创建一个继承Thread的类,并重写run方法

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

run方法里就是此线程所具体要执行的任务.而当我们执行start方法时,这个线程才算是真的有了,并开始执行run方法~

run和start的区别之后会讲~

方法②:创建一个类实现 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();
    }
}

方法③:用匿名内部类简写方法①

关于匿名内部类:

匿名内部类，顾名思义，就是没有名字的类，匿名内部类格式如下：

new name(parameter) {
 ......
};

name:父类或者接口的名字,匿名内部类继承于这个类~

parameter:若name为父类,则parameter为父类构造函数的参数~

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

匿名内部类继承字Thread类,并重写了run方法

方法④:用匿名内部类简写方法②

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

匿名内部类实现了这个接口并将实例传入构造函数的参数中

方法⑤:使用lambda表达式简化方法④

关于lambda表达式:

本质上是一个匿名方法,示例:

public int add(int x, int y) {
        return x + y;
}

使用lambda表达式后是这样的~:

(int x , int y) -> x + y;

甚至参数类型都可以省略~:

(x , y) -> x + y;

Java编译器会根据上下文推断出来~

------------------------------------------------------------------------------------------------------------------------

那么回到线程这边~

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

使用lambda省略了 Runnable参数类型(Thread方法的构造方法里需要的类型是Runnable,编译器能推断出来),并省略了方法名,直接写需要执行的任务~

( )代表这个方法是没有参数的~

->代表这是一个lambda表达式~

{ ~~~~~~ }大括号里的是需要执行的任务~

多线程运行

我们知道线程是为了实现 " 并发编程 ",但上述代码并没有体现到这点,现在来体验一下:

public class demo12 {
    public static void main(String[] args) {
        Thread t1 = new Thread( () ->{
            while(true){
                System.out.println("hello I am thread1");
                //由于线程的运行速度很快,我们人眼观测不出来
                //所以使用sleep休眠1000毫秒也就是1秒
                try {
                    thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        while(true){
            System.out.println("hello I am main");
            try {
                thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 关于sleep:

 关于main线程:

Java中一旦创建了一个项目就会有一个main线程存在~

run()方法与start()方法的区别

前面就提到了start方法才是真正创建一个线程的方法,那么run方法又是啥呢?

run方法其实就是这个类的一个实例方法,只要调用就会执行里面的内容~

举个例子:

我们发现在这个线程中,run方法与start打印内容一致~

但这个呢:

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

当我们创建一个进程并分别对main线程和t1线程执行5次时:

当我们执行start时,线程被创建,时间管理大师将其排入时间表中,两个线程一同运行~

 

 当我们执行run方法时,是串行(顺序)执行的,因为这个线程并没有被建立,由main线程来调用这个方法

多线程的优势

多线程能提高任务完成的效率~

我们现在假设一个任务是让变量a和b自增10亿次,采用多线程和单线程进行比较~

public class demo7 {
    private static final long count = 10_0000_0000l;
    //串行执行(单线程)
    public static void serial(){
        //记录开始时间
        long begin = System.currentTimeMillis();
        long a = 0;
        for (long i = 0; i < count; i++) {
            a++;
        }
        long b = 0;
        for (long i = 0; i < count; i++) {
            b++;
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println(end - begin);
    }
    //多线程
    public static void current() throws InterruptedException {
        long beg = System.currentTimeMillis();
        Thread t1 = new Thread(() ->{
            long a = 0;
            for (long i = 0 ; i < count ; i++){
                a++;
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            long b = 0;
            for(long i = 0 ; i < count ;i ++){
                b++;
            }
        });
        t2.start();
        //此处不能直接求出结束时间,因为这两个线程是和main线程一起并发执行的,
        //此时t1,t2还没执行完,就已经计算出结束时间了,这显然是不科学的
        //因此正确的做法是,让main等待t1t2线程结束后才计算时间
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println(end - beg);
    }
    public static void main(String[] args) throws InterruptedException {
        serial();
        current();
    }
}

在这段演示代码中,我们加入了新的函数join(),这个函数代表主线程需要等到这个线程结束后才真正的结束~

我们注意到多线程只比单线程快了3分之1左右,这是因为两个线程在运行时并没有真正的实现并行,可能并行也可能并发~

 多线程的缺点

创建线程也是有开销的,虽然这个开销不会很大,但如果数据量较小时使用多线程速度反而会降低~

当我们将原代码数据量减小到1亿次和1000万次时,可以观察到单线程比多线程还要快,说明创建者两个线程大致要花费100毫秒左右~~

线程中断

一般通过Thread创建的线程,想让一个线程停下来的关键,就是要让线程对应的run方法执行完成(这是中断线程的关键)~~

一个特例:main线程必须等到main方法执行完后才会停止~~

下面是几种中断线程的方法:

 方法①:通过设置一个标志位,来控制线程是否要执行的结果

public class demo13 {
    private static boolean flg = false;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while(!flg){
                System.out.println("hello thread1");
                try {
                    thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        try {
            thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flg = true;
        System.out.println("main线程结束");
    }
}

方法②:使用Thread内置的标志位进行判定

这段代码希望t1线程应在5秒后中断~

但!!!

实际情况却是线程在5秒后抛出了一个异常并且继续运行!!!

这就是interrupt的另一个作用,当线程处于阻塞状态,以异常方式提醒~

对于线程t1来说,休眠1秒其实和我们人的世界过了一个月一样漫长~

因此线程t1其实大部分时间都处于阻塞状态,触发异常也就很正常了~~

那么怎么修改呢?我们发现:

虽然catch语句捕捉到了异常信息,但却什么都不干,这可不行,我们要让他在捕捉到异常后做出反应来中断线程,直接break就好了~

关于线程interrupted()和isInterrupted()  :

 关于标志位清除:

测试:

线程等待

多线程中,线程的调度顺序不确定~

有些我们需要控制线程的调度顺序~而线程等待就是其中一种控制执行顺序的方式~

此处的线程等待其实控制的是线程结束的顺序~

使用的方法为 join(),我们前面在自增一个变量时用到过,当时使用的是让main线程等待t1,t2~

join()在默认情况下是死等,也就是说等待的那个线程没结束就一直等着,这是非常不合理的,因此我们可以为其设置参数,标明等待多少秒~

线程休眠

线程休眠即是我们使用了sleep之后线程产生的情况~

那么线程的休眠到底在干啥~或者说干了啥~

我们在前文就说了一个进程只有一个PCB(但前提是一个进程只有一个线程~),像这种一个进程有很多线程的就有多个PCB~,而每个PCB都有唯一的pid与之对应~

因此严格来说是每个线程有一个PCB,而一个进程有一组PCB~

多线程带来的风险--线程安全

线程的状态

对于这些线程的状态,其实是Java内部搞出来的状态,和操作系统的PCB中的状态没有关系~

至于为什么要这么划分~

这是非常有好处的~在程序员的开发过程中,进程会遇到卡死的情况~

其实是一些关键的线程阻塞了~

在分析卡死的情况,第一步就是判定线程所处的状态~

线程安全

操作系统调度线程是随机(抢占式执行)~

正是因为这样的随机性,就可能导致程序出现一些bug~

如果因为调度随机性引入了bug,就认为是线程不安全的~

反之,则认为线程是安全的~

一个栗子:

public class demo18 {
    public static int count = 0;
    private static void crease(){
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                crease();
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                crease();
            }
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

我们用两个线程同时操作同一个变量count,对它自增5万次~

按道理应该是一个线程5万,但实际上却不是,那么count++到底干了啥?

站在cpu的角度上来看,count++实际上是三个cpu指令~

分别是 load(加载) , add(自增) , save(保存)~

正是因为前面的抢占式执行,两个线程执行这三个指令是完全随机排列的~

可能有下列各种情况~

 分析一种:

在这些各种随机顺序下,count可能是串行执行(+2),也可能交错(+1)~

如何解决上述问题?

想象一下平时我们在银行取钱~

 当我们取钱时会把门锁上,此时别人进不来,只有等你取完后开锁才能进去~

就类似于我们上述的代码对同一个变量count(ATM)操作时,先加锁,操作完后再开锁~

示例:

 线程不安全的原因

关于编译器优化:

编译器优化是一个很神奇的东西,但我们也不能确保啥时候会优化啥时候不会优化~

当我们写出如上一段代码后,发现我们虽然通过输入改变了isQuit的值,但t1线程似乎并没有读取到(如果读取到了会输出t1线程结束~~) 这里面就发生了编译器优化,线程对isQuit频繁的读取,开始偷懒了,就不在进行读取了,这时改变的isQuit的值它也就读取不到了~~

而当我们对其进行修改~

加入了一段休眠,发现编译器又没有进行优化了,可能就是因为t1没有在频繁的读取isQuit的值~

预知后事如何请听下回分解~~