线程，安全，通信

作者: 云承寒 | 来源:发表于2017-05-11 15:30 被阅读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方法，因此能开启线程

线程中常用的方法

方法	作用
Thread(String name)	设置线程名称
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.线程默认都不是守护线程。

线程，安全，通信

进程与线程

多线程

多线程的弊端

线程的生命周期

线程的实现方式

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

线程中常用的方法

定时器

线程安全问题

出现线程安全问题的原因

解决线程安全的办法

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

2.使用 synchronized 同步函数解决

3.使用 Lock 来代替 synchronized

线程通信

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

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

线程停止，礼让，守护

线程停止

线程礼让

线程守护

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读