线程，安全，通信

最新推荐文章于 2024-04-04 08:00:00 发布

wowojiani

最新推荐文章于 2024-04-04 08:00:00 发布

阅读量200

点赞数

分类专栏： java 文章标签： java thread

本文链接：https://blog.csdn.net/wowojiani/article/details/80560755

版权

java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

进程与线程

在操作系统中，正在运行的程序称为进程，进程负责程序内存空间的分配。
进程包含线程，每条线程都是进程中代码的一条执行路径，是进程的实际运作单位。
一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程

在一个进程中有多个线程同时在执行不同的任务的行为。
一个Java应用程序中至少有两个线程：一个是主线程，负责main方法代码的执行，一个是垃圾回收器线程，负责回收垃圾。
能让一个进程同时执行多个任务，提高资源的利用率（不是效率）。

多线程的弊端

增加了CPU的负担，降低了一个进程中线程的执行概率。
会引发线程安全问题，出现了死锁现象。

线程的生命周期

这里写图片描述

线程的实现方式

public class Main {

    public static void main(String[] args) {

        1.继承方式开启线程
        Demo1 demo = new Demo1();
        demo.start();

        2.实现接口方式开启线程
        Demo2 demo2 = new Demo2();
        Thread thread = new Thread(demo2);
        thread.start();
    }
}

1.继承方式开启线程
class Demo1 extends Thread {

    @Override
    public void run() {
        super.run();
    }
}

2.实现接口方式开启线程
class Demo2 implements Runnable {

    @Override
    public void run() {

    }
}

匿名内部类方式开启线程
public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();
    }

接口实现方式开启线程的细节

Runnable实现类的对象，不是线程对象，只是Runnable实现类的对象。
只有Thread或者Thread子类的对象才是线程对象，所以需要将Runnable实现类对象作为参数，放入Thread构造方法中。
推荐使用接口实现的方式，因为Java的单继承，多实现。

从源码看，Runnable实现类的对象作为实参传递给Thread的作用

      //SellTicket是Runnable的实现类
    SellTicket sellTicket = new SellTicket();

      //开启一个线程，将sellTicket传入，看这一段的源码
    Thread thread1 = new Thread(sellTicket, "1号");

     //源码
    public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }

    //Thread的构造方法接收sellTicket，然后看看Thread.run()开启线程源码
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
//意思是在Thread类的run中调用了将传入的实现类的run方法，因此能开启线程

线程中常用的方法

方法	作用
setName(String name)	设置线程名称
getName()	获取线程名称
setPriority(int prioity)	设置线程的优先级(1~10)
getPriority()	获取线程的优先级

public static void main(String[] args) {

        Thread thread = new Thread(new Demo(), "线程1");
        thread.setName("重新设置线程名称");
        System.out.println(thread.getName());

        // 线程的优先级默认为5,优先级的范围为1~10
        thread.setPriority(10);
        thread.getPriority();
        Thread.currentThread().getPriority();
        thread.start();
}

class Demo implements Runnable {
    @Override
    public void run() {

    }
}

静态方法	作用
sleep(long time)	在哪个线程调用，哪个就睡眠
currentThread()	在哪个线程调用，就返回哪个线程的对象

public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new Demo(), "线程1");

        Thread.sleep(1000); //主线程睡眠

        Thread threadMain = Thread.currentThread(); //返回主线程对象
        System.out.println("返回主线程：" + threadMain.getName());
        thread.start();
}

class Demo implements Runnable {

    @Override
    public void run() {
        // 为什么这里的异常只能捕获处理，不能抛出处理。
        //因为Thread类的run()方法没有抛出异常，因此子类不能抛出。
        try {
            Thread.sleep(1000); //子线程睡眠

            Thread threadChild = Thread.currentThread();//返回子线程对象
            System.out.println("返回子线程：" + threadChild.getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

定时器

public static void main(String[] args) {

        Timer定时器工具类，会在主线程之外发起一个单独的线程执行指定的计划任务。
        TimerTask是一个实现了Runnable接口的抽象类，代表一个可以被Timer执行的任务。

        new Timer().schedule(new TimerTask() {
            int count = 0;

            @Override
            public void run() {
                System.out.println("" + count++);
            }

        }, 1000, 2000);1s后执行，每隔2s触发一次
    }

线程安全问题

出现线程安全问题的原因

存在两个或两个以上的线程对象，操作共享同一个资源。

public static void main(String[] args) {

        SellTicket sellTicket = new SellTicket();

        for (int i = 1; i <= 3; i++)
            new Thread(sellTicket, "线程" + i).start();
}

class SellTicket implements Runnable {
    //待售票
    //这里区别于Thread的方式，不需要用static，因为操作的是一个对象
    private int ticket = 50;

    @Override
    public void run() {

        while (true) {
            if (ticket > 0) {
                System.out.println(
                        Thread.currentThread().getName()
                                + "销售了第："
                                + ticket
                                + "号票");
                ticket--;
            } else {
                System.out.println("票已售完");
                break;
            }
        }
    }
}

线程紊乱

解决线程安全的办法

1.使用synchronized 同步代码块解决

synchronized (锁对象){

}

注意
1.任意的对象都可以作为锁对象，但是，多线程操作的锁对象必须是共享唯一的对象，可用Object。
2.只有真正存在线程安全问题的时才使用同步代码块，否则会降低效率。
3.在同步代码块中调用了sleep()方法，并不释放锁。
4.凡是对象内部都维护了一个状态，Java同步机制就是使用这个状态作为锁的标识。

class SellTicket implements Runnable {

    private int ticket = 50;

    @Override
    public void run() {

        while (true) {
            //添加同步代码块
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println(
                            Thread.currentThread().getName()
                                    + "销售了第："
                                    + ticket
                                    + "号票");
                    ticket--;
                } else {
                    System.out.println("票已售完");
                    break;
                }
            }
        }
    }
}

2.使用 synchronized 同步函数解决

将 synchronized  添加到需要同步的函数上

public synchronized void run() {


}

注意
1.同步函数的锁对象是固定的，不能由自己指定。
2.如果是一个非静态的同步函数，那么它的锁对象是this，它本身。
3.如果是静态的同步函数，那么它的锁对象是当前函数所属类的字节码文件(class对象)。

class SellTicket implements Runnable {

    private int ticket = 50;

    @Override //添加同步函数
    public synchronized void run() {

        while (true) {
            if (ticket > 0) {
                System.out.println(
                        Thread.currentThread().getName()
                                + "销售了第："
                                + ticket
                                + "号票");
                ticket--;
            } else {
                System.out.println("票已售完");
                break;
            }
        }
    }
}
推荐使用同步代码块
1.同步代码块的锁对象可以自由指定，方便控制，而同步函数的锁对象是固定的。
2.同步代码块可以控制同步代码的范围，同步函数作用范围是整个函数，将函数内所有代码都同步。

3.使用 Lock 来代替 synchronized

public static final ReentrantLock LOCK = new ReentrantLock();

public void run() {

        LOCK.lock();
        try {

            //线程的操作资源

        } finally {
            LOCK.unlock();
        }
}

class SellTicket implements Runnable {

    private int ticket = 50;
    public static final ReentrantLock LOCK = new ReentrantLock();

    @Override
    public void run() {

        while (true) {
            LOCK.lock();
            try {
                if (ticket > 0) {
                    System.out.println(
                            Thread.currentThread().getName()
                                    + "销售了第："
                                    + ticket
                                    + "号票");
                    ticket--;
                } else {
                    System.out.println("票已售完");
                    break;
                }
            } finally {
                LOCK.unlock();
            }
        }
    }
}

线程通信

1.使用 wait()，notify() 实现线程通信

线程通信指当一个线程完成自己的任务时，就去通知另外一个线程去完成另外一个任务。

wait()
1.线程执行wait()后，将进入以锁对象为标识符的线程池中等待。
2.等待状态下，只能被其他线程调用notify()才能唤醒。
3.执行wait()会释放锁。


notify()
线程执行了notify()后，将唤醒以锁对象为标识符在线程池中等待的线程中的一个。

notifyAll()
唤醒线程池中所有等待的线程。

注意
1.wait()，notify()必须由锁对象调用。
2.wait()，notify()必须在同步代码块或者同步函数中使用。
3.wait()，notify()是属于Object内的方法。

典型模式：生产者不断生产商品，消费者不断消费商品。

public static void main(String[] args) {
        Product product = new Product();
        new Thread(new Producer(product)).start();
        new Thread(new Consumer(product)).start();
}


// 产品类
class Product {
    private String name;
    private double price;

    // 产品是否生产的标志，默认没有生产完成
    boolean flag = false;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

//生产者
class Producer implements Runnable {

    private Product mProduct;

    public Producer(Product product) {
        mProduct = product;
    }

    @Override
    public void run() {
        int i = 0;
        while (true) {
            synchronized (mProduct) {

                if (mProduct.isFlag() == false) {
                    if (i % 2 == 0) {
                        mProduct.setName("苹果");
                        mProduct.setPrice(10.5);
                    } else {
                        mProduct.setName("樱桃");
                        mProduct.setPrice(20.5);
                    }

                    i++;
                    System.out.println("生产者：生产了："
                            + mProduct.getName()
                            + "价格为："
                            + mProduct.getPrice());

                    mProduct.setFlag(true);
                    mProduct.notify(); //唤醒消费者消费
                } else {
                    try {
                        mProduct.wait();// 已经生产完毕，等待消费
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

//消费者
class Consumer implements Runnable {

    private Product mProduct;

    public Consumer(Product product) {
        mProduct = product;

    }

    @Override
    public void run() {
        while (true) {
            synchronized (mProduct) {
                if (mProduct.isFlag() == true) {
                    System.out.println("消费者：消费了："
                            + mProduct.getName()
                            + "价格为："
                            + mProduct.getPrice());

                    mProduct.setFlag(false);
                    mProduct.notify();
                }else{
                    try {
                        mProduct.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

2.使用 Lock、Condition 实现线程通信

public static final ReentrantLock LOCK = new ReentrantLock();
public static final Condition CONDITION = LOCK.newCondition();

ReentrantLock：用来解决线程安全问题

Condition：用来实现线程通信
CONDITION.signalAll()：唤醒等待线程
CONDITION.await()：使线程等待

// 产品类
class Product {
    private String name;
    private double price;

    // 产品是否生产的标志，默认没有生产完成
    boolean flag = false;

    public static final ReentrantLock LOCK = new ReentrantLock();
    public static final Condition CONDITION = LOCK.newCondition();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

//生产者
class Producer implements Runnable {

    private Product mProduct;

    public Producer(Product product) {
        mProduct = product;
    }

    @Override
    public void run() {
        int i = 0;
        while (true) {

            Product.LOCK.lock();
            try {
                if (mProduct.isFlag() == false) {
                    if (i % 2 == 0) {
                        mProduct.setName("苹果");
                        mProduct.setPrice(10.5);
                    } else {
                        mProduct.setName("樱桃");
                        mProduct.setPrice(20.5);
                    }

                    i++;
                    System.out.println("生产者：生产了："
                            + mProduct.getName()
                            + "价格为："
                            + mProduct.getPrice());

                    mProduct.setFlag(true);
                    Product.CONDITION.signalAll();

                } else {
                    Product.CONDITION.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                Product.LOCK.unlock();
            }
        }
    }
}

//消费者
class Consumer implements Runnable {

    private Product mProduct;

    public Consumer(Product product) {
        mProduct = product;

    }

    @Override
    public void run() {
        while (true) {

            Product.LOCK.lock();
            try {
                if (mProduct.isFlag() == true) {
                    System.out.println("消费者：消费了："
                            + mProduct.getName()
                            + "价格为："
                            + mProduct.getPrice());

                    mProduct.setFlag(false);
                    Product.CONDITION.signalAll();

                } else {
                    Product.CONDITION.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                Product.LOCK.unlock();
            }
        }
    }
}

线程停止，礼让，守护

线程停止

1.一般线程都存在循环，通过控制其循环条件的变量来停止线程。
2.如果线程做了相应的wait()，就需要调用notify()或interrupt()来停止。
3.interrupt()会中断线程，同时清除线程临时堵塞状态。
4.interrupt()会抛出一个InterruptedException异常，相当于强制停止线程。

public static void main(String[] args) {
        Demo demo = new Demo();
        Thread thread = new Thread(demo);
        thread.start();

        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                demo.flag = false;
                demo.interrupt();
            }
        }, 3000);
}

class Demo extends Thread {

    public boolean flag = true;

    @Override
    public void run() {

        while (flag) {
            System.out.println("Test");
        }
    }
}

线程礼让

join()
1.线程如果执行join()，就意味着有新线程加入。
2.执行join()的线程必须要让步给新加入的线程，等新线程完成任务后才能继续执行。

yield()
表示当前线程对象提示调度器自己愿意让出CPU资源，但是调度器可以自由忽略该提示。

线程守护

isDaemon()：判断一个线程是否为守护线程。
setDaemon(boolean on)：设置一个线程为守护线程。

注意
1.守护线程依存于主线程，主线程消亡，守护线程消亡。
2.在一个进程中如果只剩下了守护线程，那么守护线程也会死亡。
3.线程默认都不是守护线程。

青春短暂，我_在路上

wowojiani

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线程，安全，通信

进程与线程在操作系统中，正在运行的程序称为进程，进程负责程序内存空间的分配。进程包含线程，每条线程都是进程中代码的一条执行路径，是进程的实际运作单位。一个进程中可以并发多个线程，每条线程并行执行不同的任务。多线程在一个进程中有多个线程同时在执行不同的任务的行为。一个Java应用程序中至少有两个线程：一个是主线程，负责main方法代码的执行，一个是垃圾回收器线程，负责回收垃圾...
复制链接

扫一扫