第十章线程

最新推荐文章于 2024-10-20 17:09:42 发布

Admin-fqw

最新推荐文章于 2024-10-20 17:09:42 发布

阅读量132

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_56280646/article/details/125906790

版权

文章目录

第十章线程

第十章线程

1，程序，进程，线程

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

进程((process)就是正在执行的程序,从Windows角度讲，进程是操作系统进行资源分配的最小单位。

线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元，隶属于进程。

2，线程和进程的关系

1）一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；

2）每一个进程至少包含一个线程(称为主线程)；在主线程中开始执行程序，java程序的入口main()方法就是在主线程中被执行的。

3）在主线程中可以创建并启动其它的线程；

4）一个进程内的所有线程共享该进程的内存资源。

3，创建线程

1）继承Thread类的方式

在Java中要实现线程，最简单的方式就是扩展Thread类，重写其中的run方法，方法原型如下：

Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行run方法。

在这里插入图片描述

package com.ffyc.thread.thread1;

public class Demo2 extends Thread{
    //创建一个线程
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("Thread:"+i);
        }
    }
}

package com.ffyc.thread.thread1;

public class Demo1 {
    public static void main(String[] args) {
        Demo2 thread=new Demo2();//创建一个线程对象
        thread.run();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main:"+i);
        }
    }
}

2）实现Runnable接口的方式

java.lang.Runnable接口中仅仅只有一个抽象方法：

public void run()

也可以通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即可；

Runnable接口的存在主要是为了解决Java中不允许多继承的问题。

实现Runnable接口的方式

在这里插入图片描述

package com.ffyc.thread.thread1;

public class Demo3 implements Runnable{
    //创建一个线程任务
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
//            try {
//                Thread.sleep(100);//让当前正在执行的线程休眠（暂停执行），休眠时间由milli s（毫秒）指定
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
        }
    }
}

继承方式和实现方式的联系与区别

【区别】

继承Thread: 线程代码存放Thread子类run方法中。

实现Runnable：线程代码存在接口的子类的run方法。

【实现Runnable的好处】

1）避免了单继承的局限性

2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

4，Thread类中的方法

常用方法

void start()--------------------------------------------------------------------------启动线程

final String getName()--------------------------------------------------返回线程的名称

final void setPriority(int newPriority)---------------------------设置线程的优先级

final int getPriority()--------------------------------------------------返回线程的优先级

final void join()---------------------------------------------------------------等待线程终止

static Thread currentThread()---------返回对当前正在执行的线程对象的引用

static void sleep(long millis)让当前正在执行的线程休眠（暂停执行），休眠时间由milli s（毫秒）指定

yield()--------------------------------------------------------------------------------线程让步

package com.ffyc.thread.thread1;

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Demo3 treadDemo3 = new Demo3();//创建一个线程任务
        Thread thread = new Thread(treadDemo3);//创建一个线程对象

        thread.start();//线程启动

        System.out.println(Thread.currentThread());//返回对当前正在执行的线程对象的引用  Thread[main,5,main]
        Thread.yield();//线程让步，退出cpu至就绪队列进行排队
        System.out.println(thread.getName());//返回线程的名称
        thread.setPriority(10);//设置线程优先级，最大值为10，最小值为1，默认值为5;
        System.out.println(thread.getPriority());//返回线程的优先级
        Thread thread1 = new Thread(treadDemo3);
        thread.join();//等待线程终止
        thread1.start();
        Thread thread2 = new Thread(treadDemo3, "线程3");//线程构造方法,给线程命名
        thread2.setName("线程——3");//线程方法，给线程命名
    }
}

5，线程优先级

1）事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；

2）优先级较高的线程有更多获得CPU的机会，反之亦然；

3）优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

调度策略

时间片

抢占式：高优先级的线程抢占CPU

Java的调度方法

1）同优先级线程组成先进先出队列，使用时间片策略

2）对高优先级，使用优先调度的抢占式策略

Thread类有如下3个静态常量来表示优先级

MAX_PRIORITY：取值为10，表示最高优先级。

MIN_PRIORITY：取值为1，表示最底优先级。

NORM_PRIORITY：取值为5，表示默认的优先级。

6，线程状态

线程在它的生命周期中会处于不同的状态：

在这里插入图片描述

线程的状态：

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对
象处于新建状态。

就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时
间片，此时它已具备了运行的条件，只是没分配到CPU资源。

运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run
（）方法定义了线程的操作和功能。

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出
CPU并临时中止自己的执行，进入阻塞状态。

死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常
导致结束。

7，守护线程

Java中的线程分为两类：用户线程和守护线程

任何一个守护线程都是整个JVM中所有非守护线程的保姆,只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；

只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

守护线程的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC(垃圾回收器)，它就是一个很称职的守护者。

用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了.

设置守护线程: setDaemon(boolean on)

注意:设置线程为守护线程必须在启动线程之前，否则会跑出一个 IllegalThreadStateException异常。

package com.ffyc.thread.thread1;

public class Demo5 extends Thread {
    //创建一个线程
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

package com.ffyc.thread.thread1;

public class Demo6 implements Runnable{
    //创建一个线程任务
    @Override
    public void run() {
        while(true){
            System.out.println("我是守护线程，我会默默地一直执行");
        }
    }
}

package com.ffyc.thread.thread1;

public class Demo7 {
    public static void main(String[] args) {
        Demo5 demo5=new Demo5();
        demo5.run();
        Demo6 demo6=new Demo6();
        Thread thread=new Thread(demo6);
        thread.setDaemon(true);//设置为守护线程。必须设置在线程开始之前
        thread.start();
    }
}

8，多线程的概念

多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。
在这里插入图片描述

何时需要多线程

1）程序需要同时执行两个或多个任务。

2）程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

多线程的优点

1）提高程序的响应.

2）提高CPU的利用率.

3）改善程序结构,将复杂任务分为多个线程,独立运行

多线程的缺点

1）线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；

2）多线程需要协调和管理，所以需要CPU时间跟踪线程；

3）线程之间对共享资源的访问会相互影响；

9，线程同步

并发与并行

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：在一个时间段内一次执行操作.例如卖票,抢购,秒杀看似同时进行,实际是一个一个执行。

多线程同步

多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，即各线程间要有先来后到；

同步就是排队+锁：

几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；为了保证数据在方法中被访问时的正确性，在访问时加入锁机制。

模拟卖票

两个窗口分别售票,票数为10张分别使用继承Thread和实现Runnable两种方式实现：

确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源。

在Java代码中实现同步：

使用synchronized(同步锁)关键字同步方法或代码块。

synchronized (同步锁）{

// 需要被同步的代码；

}

synchronized还可以放在方法声明中，表示整个方法,为同步方法。

例如：

public synchronized void show (String name){

// 需要被同步的代码；

}

package com.ffyc.thread.thread1;


public class Ticket implements Runnable{
    /*
    将票数定位static，以此来达到数据共享的目的
    再调用synchronized方法，用来控制卖票时只进去一个线程
     */

    static int num=10;
    static Object object=new Object();
    @Override
    public void run() {
        synchronized (object){
            while (true){
                if(num>0) {
                    System.out.println(Thread.currentThread().getName() + ":" + num--);
                }else{
                    break;
                }
            }
        }
    }
}

package com.ffyc.thread.thread1;

public class TicketDemo {
    public static void main(String[] args) {
        /*
        模拟卖票

         */
        Ticket ticket=new Ticket();
        Thread thread=new Thread(ticket,"窗口一");
        Thread thread1=new Thread(ticket,"窗口二");
        thread.start();
        thread1.start();
    }
}

同步锁

同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用

来充当锁标记).

同步执行过程

1.第一个线程访问，锁定同步对象，执行其中代码.

2.第二个线程访问，发现同步对象被锁定，无法访问.

3.第一个线程访问完毕，解锁同步对象.

4.第二个线程访问，发现同步对象没有锁，然后锁定并访问.

一个线程持有锁会导致其他所有需要此锁的线程挂起；在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题.

10，Lock

从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁11，线程通信。

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁.

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.

案例:中国人和美国人吃饭

正常情况:

中国人:两个筷子

美国人:刀和叉

特殊情况:

中国人: 一个筷子一把刀

美国人:一个筷子一把叉

设计时考虑清楚锁的顺序，尽量减少嵌套的加锁交互数量。

package com.ffyc.thread.thread1;

public class DieLock implements Runnable{
    static Object object=new Object();
    static Object object1=new Object();
    boolean flag;

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

    @Override
    public void run() {

            if(flag){
                synchronized (object){
                    System.out.println(Thread.currentThread().getName()+"object");
                    synchronized (object1){
                        System.out.println(Thread.currentThread().getName()+"object1");
                    }
                }
            }else{
                synchronized (object1) {
                    System.out.println(Thread.currentThread().getName() + "object1");
                    synchronized (object){
                        System.out.println(Thread.currentThread().getName()+"object");
                    }

            }
        }
    }
}

package com.ffyc.thread.thread1;

public class DieLockDemo {
    public static void main(String[] args) {
        //死锁：就是一个线程调用另一个线程的资源，但是另一个线程又调用当前线程的资源，由于他们在互相等待线程锁的释放而一直处于僵持状态
        DieLock dieLock=new DieLock(true);
        Thread thread=new Thread(dieLock);
        thread.start();
        DieLock dieLock1=new DieLock(false);
        Thread thread1=new Thread(dieLock1);
        thread1.start();
    }
}

两个线程交替打印1-100之间的数字

package com.ffyc.thread.thread1;

public class PrintNum implements Runnable{
    int n=1;
    @Override
    public void run() {
        while (true){
            synchronized (this) {
                this.notify();//释放等待的一个锁（如果有多个锁，那么就会释放优先级最高的锁），this.notifyAll()释放所有的锁
                System.out.println(Thread.currentThread().getName()+":"+n++);
                if (n == 100) {
                    break;
                }
                try {
                    this.wait();//让当前线程阻塞，并且释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.ffyc.thread.thread1;

public class PrintNumDemo {
    public static void main(String[] args) {
        //创建两个线程，然后交替打印出1——100的数字
        PrintNum printNum=new PrintNum();
        Thread thread=new Thread(printNum);
        Thread thread1=new Thread(printNum);
        thread.start();
        thread1.start();
    }
}

package com.ffyc.thread.thread1;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PrintTicket implements Runnable {

    int num = 10;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
            while (true) {
                lock.lock();//获取锁
                try {
                    if (num > 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + num);
                        num--;
                    } else {
                        break;
                    }
                }finally {
                    lock.unlock();//释放锁
                }
            }

    }
}

线程通讯指的是多个线程通过相互牵制，相互调度，即线程间的相互作用。

涉及三个方法：

wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。notifyAll一旦执行此方法，就会唤醒所有被wait的线程。

注意： .wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。

经典例题：生产者/消费者问题

生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台

处取走产品，生产者一次只能生产固定数量的产品(比如:1），这时柜台中不能再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待.

package com.ffyc.thread.hm2;


public class Cusromer implements Runnable {
    Counter counter;
    private int num;

    public Cusromer(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        while (true){
            synchronized (this){
                this.notify();
                if(counter.num==1){
                    counter.sub();
                    System.out.println("消费者消费了一件商品");
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

package com.ffyc.thread.hm2;



public class Productor  implements Runnable {
    Counter counter;
    public Productor(Counter counter) {

        this.counter = counter;
    }
    @Override
    public void run() {
        while (true){
            synchronized (this){
                this.notify();
                if(counter.num==0){
                    counter.add();
                    System.out.println("生产者生产了一件商品");
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

package com.ffyc.thread.hm2;

public class Counter {
    int num=0;
    public void add(){
        this.num=1;
    }
    public void sub(){
        this.num=0;
    }
}

package com.ffyc.thread.hm2;

public class Test {
    public static void main(String[] args) {
        Counter counter=new Counter();
        Productor productor=new Productor(counter);
        Cusromer cusromer=new Cusromer(counter);
        Thread thread=new Thread(productor);
        Thread thread1=new Thread(cusromer);
        thread.start();
        thread1.start();
    }
}

12，新增创建线程方式

实现Callable接口与使用Runnable相比，Callable功能更强大些.

1）相比run（）方法，可以有返回值

2）方法可以抛出异常

3）支持泛型的返回值

4）需要借助FutureTask类，获取返回结果

接收任务

FutureTask futureTask = new FutureTask(任务);

创建线程

Thread t = new Thread(futureTask);

t.start();

Integer val = futureTask.get();获得线程call方法的返回值

ead.hm2;

public class Test {
public static void main(String[] args) {
Counter counter=new Counter();
Productor productor=new Productor(counter);
Cusromer cusromer=new Cusromer(counter);
Thread thread=new Thread(productor);
Thread thread1=new Thread(cusromer);
thread.start();
thread1.start();
}
}