线程,安全,通信

进程与线程
  • 在操作系统中,正在运行的程序称为进程,进程负责程序内存空间的分配。

  • 进程包含线程,每条线程都是进程中代码的一条执行路径,是进程的实际运作单位。

  • 一个进程中可以并发多个线程,每条线程并行执行不同的任务。

多线程
  • 在一个进程中有多个线程同时在执行不同的任务的行为。

  • 一个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.线程默认都不是守护线程。
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 199,064评论 5 466
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 83,606评论 2 376
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 146,011评论 0 328
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 53,550评论 1 269
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 62,465评论 5 359
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 47,919评论 1 275
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 37,428评论 3 390
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 36,075评论 0 254
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 40,208评论 1 294
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,185评论 2 317
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,191评论 1 328
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 32,914评论 3 316
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 38,482评论 3 302
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,585评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,825评论 1 255
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 42,194评论 2 344
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 41,703评论 2 339

推荐阅读更多精彩内容

  • 本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。 首先讲...
    李欣阳阅读 2,433评论 1 15
  • Java多线程学习 [-] 一扩展javalangThread类 二实现javalangRunnable接口 三T...
    影驰阅读 2,944评论 1 18
  • 下面是我自己收集整理的Java线程相关的面试题,可以用它来好好准备面试。 参考文档:-《Java核心技术 卷一》-...
    阿呆变Geek阅读 14,734评论 14 507
  • 前言 多线程并发编程是Java编程中重要的一块内容,也是面试重点覆盖区域,所以学好多线程并发编程对我们来说极其重要...
    嘟爷MD阅读 7,302评论 21 272
  • 富豪的成功习惯 1,冥想。 2,早起,早起的鸟儿有虫吃。早起路上不堵车。 3,仪式感,寻找适合自己的仪式感。 4,...
    阿硕的苹果阅读 214评论 0 0