多线程的奥秘

最新推荐文章于 2024-08-18 21:36:31 发布

为人师表好少年

最新推荐文章于 2024-08-18 21:36:31 发布

阅读量171

点赞数

文章标签： java thread

本文链接：https://blog.csdn.net/weixin_44051038/article/details/106744816

版权

一进程与线程

1. 进程

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

2. 线程

线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

一个正在运行的软件(如迅雷)就是一个进程，一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件，每个下载任务就是一个线程), 可以简单的认为进程是线程的集合。

线程是一条可以执行的路径。多线程就是同时有多条执行路径在同时(并行)执行。

3. 进程与线程的关系

一个程序就是一个进程，而一个程序中的多个任务则被称为线程。进程是表示资源分配的基本单位，又是调度运行的基本单位。，亦即执行处理机调度的基本单位。进程和线程的关系：

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。

资源分配给进程，同一进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量，即每个线程都有自己的堆栈和局部变量。

处理机分给线程，即真正在处理机上运行的是线程。

线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

如果把上课的过程比作进程，把老师比作CPU，那么可以把每个学生比作每个线程，所有学生共享这个教室(也就是所有线程共享进程的资源)，上课时学生A向老师提出问题，老师对A进行解答，此时可能会有学生B对老师的解答不懂会提出B的疑问(注意：此时可能老师还没有对A同学的问题解答完毕)，此时老师又向学生B解惑，解释完之后又继续回答学生A的问题，同一时刻老师只能向一个学生回答问题(即：当多个线程在运行时，同一个CPU在某一个时刻只能服务于一个线程，可能一个线程分配一点时间，时间到了就轮到其它线程执行了，这样多个线程在来回的切换)

4. 为什么要使用多线程

多线程可以提高程序的效率。

实际生活案例：村长要求喜洋洋在一个小时内打100桶水，可以喜洋洋一个小时只能打25桶水，如果这样就需要4个小时才能完成任务，为了在一个小时能够完成，喜洋洋就请美洋洋、懒洋洋、沸洋洋，来帮忙，这样4只羊同时干活，在一小时内完成了任务。原本用4个小时完成的任务现在只需要1个小时就完成了，如果把每只羊看做一个线程，多只羊即多线程可以提高程序的效率。

5. 多线程应用场景
一般线程之间比较独立，互不影响
一个线程发生问题，一般不影响其它线程

二多线程常用方法

start()	启动当前线程,调用run()
run()	通常需要重写Thread()类中的方法,将创建的线程要执行的操作声明在此方法中
`currentThread()`	静态方法,返回执行的当前代码的线程
getName()	获取当前线程的名字
setName()	设置当前线程的名字
yield()	释放当前cpu的执行权,重新进入就绪状态
join()	在线程a中调用线程b的join(),此时线程a就会进入阻塞状态,直到线程b完全执行完毕后,线程a才会结束阻塞状态例如:我在餐厅排队买饭,然后旁边来了一个girl,我比较绅士的让她先买,等她买完我在继续买饭
stop()	已过时,当执行此方式时,强行结束当前线程
sleep(long milltime)	让当前线程"睡眠"指定的millitime毫秒,在指定的millitime毫秒时间内,当前线程是阻塞状态
isAlive()	判断当前线程是否存活

线程优先级

`MAX_PRIORITY`	最大优先级=10
`MIN_PRIORITY`	最小优先级=1
`NORM_PRIORITY`	默认优先级=5
`getPriority()`	返回此线程的优先级
`setPriority(int newPriority)`	更改此线程的优先级

注意:不是更改优先级,就会线程A执行完在执行B,优先级只是更改了CPU调用不同线程的概率,所以CPU调用线程还是不能干涉,但是我们可以调整调用的概率

线程的状态

创建（new）状态: 准备好了一个多线程的对象，即执行了new Thread(); 创建完成后就需要为线程分配内存
就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
运行（running）状态: 执行run()方法
阻塞（blocked）状态: 暂时停止执行线程，将线程挂起(sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
死亡（terminated）状态: 线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)

Thread类中规定有一个类规定了线程的状态

//使用枚举类来规定常量
public enum State {

        NEW,//新建状态,new创建后的线程处理该状态
        RUNNABLE,//就绪状态,start()启动的线程处于该状态
        BLOCKED,//阻塞锁状态
        WAITING,//被wait()/join()的线程处于该状态
        TIMED_WAITING,//被wait(time)/sleep(time)/join()的线程处于该状态
        TERMINATED;//线程处理结束
    }

多线程的实现方式一:

package com.wjl.thread;

public class ThreadTest {

    public static void main(String[] args) {
        //3.创建线程类的子类对象
        MyThread thread01 = new MyThread();
        //4.调用此对象的start()方法
        thread01.start();

        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "------>" + i);
        }

    }
}
//1.创建类继承线程类
class MyThread extends Thread{

    //2.重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "------>" + i);
        }
    }
}

运行结果

发现运行之后,每次的结果都不一样,因为多个线程启动之后,线程会随机获取CPU的执行权,所以两个线程的每次执行顺序都不同

注意事项

1 调用线程必须使用start()方法,不能使用run()方法,因为使用run()方法,就不存在多线程，都是1个线程

2 同1个线程不能多次调用start()方法,不然会报IllegalThreadStateException非法线程状态异常

线程常用方法测试

1) yield()

2)setName()

3)join()

4)sleep()

多线程的实现方式二

package com.wjl.thread;

public class ThreadTest03 {

    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread02 thread02 = new MyThread02();
        //4.将此对象作为参数传入到Thread类的构造器中,构建Thread类的对象
        Thread thread = new Thread(thread02);
        //5.通过thread的对象启动start()
        thread.start();
    }
}
//1.实现Runnable接口
class MyThread02 implements Runnable{

    //2.重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

方式一VS方式二的区别

开发中,优先选择:实现Runnable接口的方式

原因:1 实现的方式没有类的单继承型的局限性

原因2: 实现的方式更适合来处理多个线程共享数据的情况

相同点:

两种方式都需要重写run(),将线程要执行的逻辑声明在run()中

多线程的实现方式三:

package com.wjl.call;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadCall {

    public static void main(String[] args) {
        //如何理解实现callable接口的方式创建多线程 比 实现Runnable接口创建多线程的方式 强大?
        //1)call()可以有返回值
        //2)call()可以抛出异常,被外面的操作捕获,获取异常的信息
        //3)Callable是支持泛型的

        //3.创建Callable接口实现类对象
        NumThread numThread = new NumThread();
        //4.将此对象作为参数传递到FutureTask构造器中
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
        //5.将fututeTask对象传入到线程对象中,因为FutureTask类也实现了Runnable接口
        Thread thread = new Thread(futureTask);
        //6.启动线程
        thread.start();

        try {
            //7.可以通过get()方法获取多线程的返回值,并且捕获异常
            Integer value = futureTask.get();
            System.out.println("返回值结果为:" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.实现Callable接口,接口可以定义泛型
class NumThread implements Callable<Integer> {

    //2.重写call()方法.实现的业务逻辑写在方法里
    @Override
    public Integer call() throws Exception {//(1)可以有返回值(2)可以抛出异常
        Integer sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

方式二 VS 方式三

如何理解实现callable接口的方式创建多线程 比 实现Runnable接口创建多线程的方式 强大?
1)call()可以有返回值
2)call()可以抛出异常,被外面的操作捕获,获取异常的信息
3)Callable是支持泛型的

解决线程安全的方式

线程安全解决方法一:同步代码块synchronized

使用方法

同步代码块

synchronized(同步监视器){

//需要被同步的代码

}

注意事项

1)操作共享数据的代码,即为需要被同步的代码

2)共享数据,多个线程共同操作的变量

3)同步监视器,俗称:锁. 任何一个类的对象,都可以充当锁

要求:多个线程必须要共用同一把锁

同步代码块处理继承Thread类的安全问题

同步监视器处理实现Runnable的线程安全问题

当使用同步代码块+Runnable接口类实现多线程时,同步监视器可以使用this,因为我们创建线程的时候this指向的是同一个对象,因为我们创建线程的时候是将那个类传入Thread类

线程安全解决方法二:同步方法

同步方法处理继承Thread类的线程安全问题

注意事项:

1 同步方法仍然涉及到同步监视器,只是不需要我们显示的声明

2 非静态的同步方法,同步监视器是:this,所以如果不加static,创建不同的线程,同步监视器就不是同一个对象

静态的同步方式,同步监视器是:当前类本身,

3 所以我们继承Thread类的线程安全需要同步方法需要修改为静态方法

同步方法处理实现Runnable类的线程安全问题

同步方法的同步监视器默认为:this

线程安全解决方式三:Lock锁

synchronized 和 Lock 的异同

相同:二者都可以解决线程安全的问题

不同:synchronized机制在执行完相同的同步代码块以后,自动的释放同步监视器

Lock需要手动的启动同步(Lock()),同步结束后也需要手动的实现解锁(unLock());

package com.wjl.thread;

import java.util.concurrent.locks.ReentrantLock;

public class ThreadTest03 {

    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread02 thread02 = new MyThread02();
        //4.将此对象作为参数传入到Thread类的构造器中,构建Thread类的对象
        Thread thread = new Thread(thread02);
        Thread thread2 = new Thread(thread02);
        //5.通过thread的对象启动start()
        thread.start();
        thread2.start();
    }
}

//1.实现Runnable接口
class MyThread02 implements Runnable {

    private static int ticket = 100;
    private Object obj = new Object();
    //创建锁
    private ReentrantLock lock = new ReentrantLock();

    //2.重写run()方法
    @Override
    public void run() {
        while (true) {
            try {
                //加锁
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "--->" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

死锁

多个线程在运行时，等待其他线程释放锁，如果锁不释放就会出现程序暂停现象，这个现象就是死锁，

package com.wjl.thread;

public class HeadLock {

    public static void main(String[] args) {
        MyLock01 myLock01 = new MyLock01(true);
        MyLock01 myLock02 = new MyLock01(false);
        Thread thread1 = new Thread(myLock01);
        Thread thread2 = new Thread(myLock02);
        thread1.start();
        thread2.start();
    }

    public static Object obj1 = new Object();
    public static Object obj2 = new Object();

}

class MyLock01 implements Runnable{

    private boolean flag;

    public MyLock01(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag){
            synchronized (HeadLock.obj1){
                System.out.println("if  obj1");
                synchronized (HeadLock.obj2) {
                    System.out.println("if obj2");
                }
            }
        }else {
            synchronized (HeadLock.obj2){
                System.out.println("else obj2");
                synchronized (HeadLock.obj1){
                    System.out.println("else obj1");
                }
            }
        }
    }
}

线程通信

常用方法

wait()	执行此方法,当前线程就进入阻塞状态,并释放同步监视器
notify()	一旦执行此方法,就会唤醒被wait的一个线程,如果有多个线程被wait,就唤醒优先级高的线程
notifyAll()	一旦执行此方法,就会唤醒所有被wait()的方法

注意事项

wait() notify()和notifyAll() 三个方法必须使用在同步代码块或同步方法中
wait() notify()和notifyAll() 三个方法的调用者必须是同步代码块或同步方法中的同步监视器,否则会出现IllegalMonitorStateException异常
wait() notify()和notifyAll() 三个方法是定义在java.lang.Object类中

sleep()和wait()的区别

相同点:一旦执行方法,都可以使得当前的线程进入阻塞状态

不同点:

两个方法声明的位置不同,Thread类中声明sleep(),Object类中声明wait()
调用的要求不同,sleep()可以在任何需要的场景下调用,wait()必须使用同步方法和同步代码块
关于是否释放同步监视器,如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,等睡眠时间结束后,继续执行这个线程, wait()会释放锁,其它线程可以获得这个锁

线程通信案例

消费者和生产者案例

苹果Apple.java

package com.wjl.test;

public class Apple {

    private int id;//苹果id
    private int num;//苹果的总数

    //生产者
    public synchronized void produce(){
        if (num != 0){//如果num不为0,就停止买苹果
            try {
                wait();//线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            num++;//苹果总数+1
            id += 1;//苹果id+1
            System.out.println(Thread.currentThread().getName() + "买了 " + id + "苹果");
            notify();//唤醒消费苹果的线程
        }
    }

    //消费者
    public synchronized void consume(){
        if (num == 0){//如果苹果为0,则停止吃苹果
            try {
                wait();//线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            num--;//吃苹果
            System.out.println(Thread.currentThread().getName() + "吃了 " + id + "面包");
            notify();//唤醒买苹果的线程
        }
    }
}

主类

package com.wjl.test;

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        Producer producer = new Producer(apple);
        Consumer consumer = new Consumer(apple);
        Thread thread1 = new Thread(producer);
        Thread thread2 = new Thread(consumer);
        thread1.start();
        thread2.start();

    }
}
class Producer implements Runnable{

    private Apple apple;//苹果实例 消费者和生产者共用的


    public Producer(Apple apple) {
        this.apple = apple;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            apple.produce();
        }
    }
}
class Consumer implements Runnable{

    private Apple apple;//苹果实例 消费者和生产者共用的

    public Consumer(Apple apple) {
        this.apple = apple;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            apple.consume();
        }
    }
}

查看结果

发现我们上面的循环是执行20次,但是这里只有14次,而且每次执行都不一样,因为线程执行是获取CPU执行权,干预不了,消费方法和生产方法不一定是是交替执行,但是不一定每次都消费/生产了苹果,可以同时执行了两次消费方法/两次生产方法

为人师表好少年

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
多线程的奥秘

一多线程的实现方式一:package com.wjl.thread;public class ThreadTest { public static void main(String[] args) { //3.创建线程类的子类对象 MyThread thread01 = new MyThread(); //4.调用此对象的start()方法 thread01.start(); for (int i = 0
复制链接

扫一扫