Java 线程

爪哇岛上的星期五

于 2022-07-16 17:23:31 发布

阅读量1.3k

点赞数 2

文章标签： java

本文链接：https://blog.csdn.net/qq_55674489/article/details/125801367

版权

我们先来分清楚何为程序，何为进程，何为线程

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

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

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

线程与进程的关系

1. 一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；
2. 每一个进程至少包含一个线程(称为主线程)；在主线程中开始执行程序， java程序的入口main()方法就是在主线程中被执行的。
3. 在主线程中可以创建并启动其它的线程；
4. 一个进程内的所有线程共享该进程的内存资源。

创建线程的方式

创建线程的方式有两种：继承Thread类的方式实现Runnable接口的方式。

继承Thread类

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

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

public class NumDemo {
    public static void main(String[] args) {
        Num num=new Num();
        num.setName("偶数线程");//更改线程的名字
        num.start();

        Num2 num2=new Num2();
        num2.setName("奇数线程");
        num2.start();
    }
}
public class Num2 extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + i);//currentThread方法是用来调出当前的线程的引用
                                                                       //getName方法可以得到线程的名字
            }
        }
    }
}
public class Num extends Thread{

    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+i);//currentThread方法是用来调出当前的线程的引用
                                                                       //getName方法可以得到线程的名字
             }
        }
    }
}

以上代码便是简单的以继承Thread类的方式，创建了两个线程。

实现Runnable接口的方式

Runnable接口之中仅仅只有一个抽象方法run（）；

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


public class PrintNum implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

}
public class Test {

    public static void main(String[] args) {

        //创建一个线程要执行的任务
        PrintNum printNum = new PrintNum();

         //创建一个线程作为外壳，将类对象包装起来
         Thread thread =   new Thread(printNum);
                thread.start();

         Thread thread1 = new Thread(printNum);
                thread1.start();
    }
}

以上代码便是简单的以实现Runnable接口的方式创建线程。

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

区别：继承Thread: 线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法。

实现Runnable的好处：

1.避免了单继承的局限性
2.多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

Thread类中常用方法

start():启动线程

String getName()：返回线程的名称

void setPriority()设置线程的优先级

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

void join()等待线程终止

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

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

yield()线程让步

getName() 返回线程名字

setName（）修改线程名字

join（）等待线程死亡

sleep（）使当前线程暂停时间

yield（）当前线程做出让步

currentThread（）返回当前线程的引用

线程优先级

事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；
1.优先级较高的线程有更多获得CPU的机会，反之亦然；
2.优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

Java的调度方法：
1.同优先级线程组成先进先出队列，使用时间片策略
2.高优先级的线程，使用优先调度的抢占式策略

Thread类有如下3个静态常量来表示优先级：
MAX_PRIORITY：取值为10，表示最高优先级。
MIN_PRIORITY：取值为1，表示最底优先级。
NORM_PRIORITY：取值为5，表示默认的优先级。

当然并不是说优先级高了就一定会抢占到cpu的调度，只是优先级高，更有机会抢到。

线程状态

线程的状态：
新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run（）方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

首先新建线程，调用start方法线程处于就绪状态，然后操作系统调度到加载权，线程便开始运行，执行完run方法调用stop方法线程死亡。

在执行状态时，若是失去cpu执行权或者使用yield方法使线程做出让步，线程便会回到就绪状态。

如果在执行状态时，使用sleep，join，wait方法，线程便会进入阻塞状态，等到sleep，join，wait方法结束，那么线程便会再进入就绪状态。

守护线程

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

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

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

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

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

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

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

 public static void main(String[] args) {

              new MyThread().start();

             DaemonThread daemonThread =  new DaemonThread();
               daemonThread.setDaemon(true);//设置线程为守护线程, 当其他用户线程结束后,守护线程自动结束,必须在启动前设置
               daemonThread.start();
    }

多线程

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

简单来说就是一个应用程序内部,可以同时执行多个任务。

何时使用多线程？

1. 程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

多线程的优缺点

优点：

1.可以提高程序的处理速度，加快响应速度

2.可以提高CPU的利用率。

3.可以改善程序结构，将复杂任务化为多个线程工作。

缺点：

1.线程越多所占有的内存就更多。

2.对硬件的需求也就提高了。

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

线程同步

线程的安全问题往往就是多线程与共同访问同一个资源而出现的。

并行: 在同一个时间节点上,多个事情同时进行。
并发: 在一个时间段内,多个事情依次执行。

同步其实就是排队+锁，这也是解决线程安全问题的解决方案。

排队指的是几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作。

锁指的是为了保证数据在方法中被访问时的正确性，在访问时加入锁机制。

下面我们给出一个代码示例方便理解

public class BuyTicket implements Runnable {
    static int num = 10;
    //Lock lock = new ReentrantLock();

    //static Object object=new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (object) {
                //lock.lock();
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num--;
                } else {
                    break;
                }
                //lock.unlock();
            }
        }
    }
}
public class BuyTicketDemo {
    public static void main(String[] args) {
        BuyTicket buyTicket=new BuyTicket();
        Thread t1=new Thread(buyTicket,"窗口1");
        Thread t2=new Thread(buyTicket,"窗口2");
        t1.start();
        t2.start();
    }
}

上图中没有添加锁，所以输出会出现错误，如下图

而当我们加入synchronized关键字时，我们会发现它每次执行任务，只能锁住固定一个线程进行工作，这样便不会出现抢公共资源的情况。

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

在高级层面解决的用synchronized关键字修饰， synchronized可以用来修饰一段代码块，而当 synchronized修饰方法时修饰非静态的方法时,锁对象是this ，修饰静态方法时,锁对象是当前类的Class对象。

同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用来充当锁标记)。因此我们图中使用static Object object=new Object()的object对象来充当同步锁因为它是唯一的。

同步执行的工作原理：

1.第一个线程访问，锁定同步对象，执行其中代码.
2.第二个线程访问，发现同步对象被锁定，无法访问.
3.第一个线程访问完毕，解锁同步对象.
4.第二个线程访问，发现同步对象没有锁，然后锁定并访问

Lock锁

从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

我们继续拿上面的买票来举例子

public class BuyTicket implements Runnable {
    static int num = 10;
    Lock lock = new ReentrantLock();
    //static Object object=new Object();
    @Override
    public void run() {
        while (true) {
            //synchronized (this) {
            try {
                lock.lock();
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num--;
                } else {
                    break;
                }
            }
            finally {
                lock.unlock();
             }
            }
        }
    }
public class BuyTicketDemo {
    public static void main(String[] args) {
        BuyTicket buyTicket=new BuyTicket();
        Thread t1=new Thread(buyTicket,"窗口1");
        Thread t2=new Thread(buyTicket,"窗口2");
        t1.start();
        t2.start();
    }
}

这次我们注释掉了synchronized关键字，改用lock锁。

因为synchronized关键字是隐式的上锁和解锁，那么当处理代码中出现异常它也会自动的解开锁。而lock锁因为是显式的上锁和解锁，如果在处理代码时碰到异常，它会卡住而运行不到解锁，从而导致结果出现问题。所以我们通常在使用lock锁是会使用try finally语句来跳过异常。

ReentrantLock 和 synchronized 区别

synchronized是关键字,实现是依靠底层编译后的指令来控制的.
synchronized可以修饰代码块和方法
synchronized是隐式锁,自动添加锁,同步代码块执行完毕或者出现异常,锁会自动释放

ReentrantLock是java.util.concurrent.locks包下的一个类,是依靠java代码实现控制
ReentrantLock只能修饰代码块
ReentrantLock是手动添加,手动释放

两者看似实现作用相差无几，但是底部实现方式是大有不同的。

线程死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁.出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

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

下面是举例一个死锁情况

public class DeadLock implements Runnable{
    Object object1=new Object();
    Object object2=new Object();
    boolean flag;

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

    @Override
    public void run() {
        if (flag){
            synchronized (object1){
                System.out.println("if中的object1");
                synchronized (object2){
                    System.out.println("if中的object2");
                }
            }
        }
        else {
            synchronized (object2){
                System.out.println("else中的object2");
                synchronized (object1){
                    System.out.println("else中的object1");
                }
            }
        }
    }
}
public class DeadLockDemo {
    public static void main(String[] args) {
        new Thread(new DeadLock(true)).start();
        new Thread(new DeadLock(false)).start();
    }
}

代码正常运行结果会是如上图这样，但是避免不了偶尔会出现true的线程与false的线程同时进入run方法中执行任务。此时true的线程在执行完object1锁的任务准备进入objecet2锁的任务，但发现另一边false的线程进入了object2的锁的任务之中等待object1锁的解锁。这时便出现了死锁，程序也便会停不下来，一直被死死的锁住。

线程通信

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

涉及三个方法：
wait（）一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify （）一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll（）一旦执行此方法，就会唤醒所有被wait的线程。
注意：wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。

线程通信这边有一个经典例题，即生产者与消费者的问题

题目描述：生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台处取走产品，生产者一次只能生产固定数量的产品(比如:1），这时柜台中不能再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待。

下面是代码示例

public class Counter {
    int num=0;
    public synchronized void add(){
        if (num==0){
            this.num++;
            System.out.println("生产者生产了一件商品");
            this.notifyAll();
        }else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void sub(){
        if (num>0){
            this.num--;
            System.out.println("消费者生拿走了一件商品");
            this.notifyAll();
        }
       else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Producter extends Thread {
    private Counter counter;

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

    @Override
    public void run() {
        while (true) {
            counter.add();
        }
    }
}
public class Customer extends Thread {
   private Counter counter;

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

    @Override
    public void run() {
        while (true) {
            counter.sub();
        }
    }
}
public class Text {
    public static void main(String[] args) {
        Counter counter=new Counter();

        new Producter(counter).start();
        new Customer(counter).start();
    }
}

可以看到我们使用的wait和notify方法后，代码实现了造一拿一的和谐现象这既是我们所说线程通信，实现多线程的相互牵制。

Callable接口

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

Callable接口有如下几个特点：
1.相比run（）方法，可以有返回值
2.方法可以抛出异常
3.支持泛型的返回值
4.需要借助FutureTask类，获取返回结果

下面我们举个栗子

public class CallableSum implements Callable<Integer> {//接口可以用泛型修饰
    int num=0;
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i <10 ; i++) {
            num+=i;
        }
        return num;
    }
}
public class CallableSumDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask <Integer>futureTask=new FutureTask(new CallableSum());
        new Thread(futureTask).start();
        Integer integer=futureTask.get();//FutureTask类的get方法可以得到返回值。
        System.out.println(integer);
    }
}