day06 【线程、同步】

最新推荐文章于 2024-12-17 10:06:30 发布

原创最新推荐文章于 2024-12-17 10:06:30 发布 · 96 阅读

0 ·

CC 4.0 BY-SA版权

java学习专栏收录该内容

31 篇文章

订阅专栏

第一章线程

1.1 多线程原理

1.2 Thread类

在我们完成操作过程中用到了java.lang.Thread类，API中该类中定义了有关线程的一些方法，具体如下：
构造方法：

public Thread():分配一个新的线程对象。
public Thread(String name):分配一个指定名字的新的线程对象。
public Thread(Runnable target):分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法：

public String getName():获取当前线程名称。
public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。public void run():此线程要执行的任务在此处定义代码。
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread():返回对当前正在执行的线程对象的引用。

翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式，方式一我们上一天已经完成，接下来讲解方式二实现的方式。

/*
获取线程的名称：
    1、使用Thread类中的方法getName()
        String getName()返回该线程的名称
    2、可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
        static Thread currentThread() 返回对当前正在执行的线程对象的引用

设置线程的名称:（了解）
    1.使用 Thread尖中的方法 setName（名字）
        void setName（String name）改变线程名称，使之与参数name相同
    2创建一个带参数的构造方法，参数传递线程的名称;调用父类的带参构造方法，把线程名称传递给父类，让父类（ Thread）给子线程起一个名字
        Thread（ String name）分配新的 Thread对象

 */
//定义一个Thread的子类
public class MyThread extends Thread{
    public MyThread() {
    }

    //创建一个带参数的构造方法，参数传递线程的名称
    public MyThread(String name) {
        super(name);//调用父类的带参构造方法，把线程名称传递给父类，让父类（ Thread）给子线程起一个名字
    }

    //重写thread类中的run方法，设置线程任务
    @Override
    public void run() {
        /*String name = getName();
        System.out.println(name);*///Thread-0 Thread-1

        /*Thread t = Thread.currentThread();
        System.out.println(t);//Thread[Thread-0,5,main] Thread[Thread-1,5,main]*/

        //链式编程
        System.out.println(Thread.currentThread().getName());//Thread-0 Thread-1
    }
}

/*
线程的名称：
    主线程：main
    新线程：Thread-0，Thread-1，Thread-2
 */
public class Demo01GetThreadName {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread mt = new MyThread();
        //调用start方法，开启新线程，执行run方法
        mt.start();
        new MyThread().start();

    }
}

public class Demo01SetThreadName {
    public static void main(String[] args) {
        //开启多线程
        MyThread mt = new MyThread();
        mt.setName("佩奇");
        mt.start();//佩奇

        //开启多线程
        new MyThread("乔治").start();//乔治
    }
}

/*
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
毫秒数结束以后，线程继续执行
 */
public class Demo01Sleep {
    public static void main(String[] args) {
        //模拟秒表
        for (int i = 0; i < 60 ; i++) {
            System.out.println(i);
            //让程序睡眠1秒钟
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1.3 创建线程方式二

1.4 Thread和Runnable的区别

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。
步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

//1创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    @Override
    //2在实现类中重写 Runnable接口的run方法，设置线程任务
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

//1创建一个Runnable接口的实现类
public class RunnableImpl2 implements Runnable{
    @Override
    //2在实现类中重写 Runnable接口的run方法，设置线程任务
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("Helloword"+"-->"+i);
        }
    }
}

/*
创建多线程程序的第二种方法
java.lang.Runnable
    Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法。
java.lang.Thread类的构造方法
    Thread（Runnable target）分配新的Thread对象
    Thread（Runnable target， String name）分配新的 Thread对象。
实现步骤
    1创建一个Runnable接口的实现类
    2在实现类中重写 Runnable接口的run方法，设置线程任务
    3创建一个Runnable接口的实现类对象
    4创建Thread类对象，构造方法中传递 Runnable接口的实现类对象
    5调用Thread类中的start方法，开启新的线程执行run方法

实现 Runnable接口创建多线程程序的好处
    1.避免了单继承的局限性
        类只能继承一个类（一个人只能有一个亲爹）类继承了 Thread类就不能继承其他的类
        实现了 Runnable接口，还可以继承其他的类，实现其他的接口
    2增强了程序的扩展性，降低了程序的耦合性（解耦）
        实现 Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）
        创建 Thread类对象调用 start方法:用来开启新线程
 */
public class Demo01Runnable {
    public static void main(String[] args) {
        //3创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4创建Thread类对象，构造方法中传递 Runnable接口的实现类对象
        //Thread t = new Thread(run);
        Thread t = new Thread(new RunnableImpl2());//打印helloword
        //5调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

1.5 匿名内部类方式实现线程的创建

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

/*
    匿名内部类方式实现线程的创建
    匿名:没有名字
    内部类:写在其他类内部的类
    匿名内部类作用:简化代码
        把子类继承父类，重写父类的方法，创建子类对象合一步完成
        把实现类实现类接口重写接口中的方法，创建实现类对象合成一步完成
    匿名内部类的最终产物:子类/实现类对象，而这个类没有名字
    格式:
        new父类/接口(){
            重复父类接口中的方法
        };
 */
public class Demo05InnerClassThread{
    public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread().start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"佩奇");
                }
            }
        }.start();

        //线程的接口Runnable
        /*Runnable r = new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"乔治");
                }
            }
        };*/
        //new Thread(r).start();
        //简化接口的方式
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"乔治");
                }
            }
        }).start();
    }
}

第二章线程安全

2.1 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们通过一个案例，演示线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟
模拟票：

发现程序出现了两个问题：

相同的票数,比如5这张票被卖了两回。
不存在的票，比如0票与-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

2.2 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。

那么怎么去使用呢？有三种方式完成同步操作：

同步代码块。
同步方法。
锁机制。

2.3 同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

/*
实现卖票案例出现了线程安全问题，卖出了不存在的票和重复的票
解决线程安全问题的一种方案：使用同步代码块
格式：
    synchronized(同步锁){
         可能会出现线程安全问题的代码（访问了共享数据的代码）
    }

注意:
1.通过代码块中的锁对象，可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用:
    把同步代码块锁住，只让一个线程在同步代码块中执行
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private int ticket = 100;
    //创建一个锁对象
    Object obj =new Object();
    @Override
    public void run() {
        while (true){
            //使用同步代码块
            synchronized (obj) {
                //判断票是否存在
                if (ticket>0){
                    //提高安全问题出现的概率，让程序睡眠
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

/*
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }

}

同步技术的原理

2.4 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

/*
    卖票案例壮现了线程安全问题
    卖出了不存在的票和重复的票
    解决线程安全问题的一种方案:使用同步代码块
    格式:
        public synchronized void method(){
   	        可能会产生线程安全问题的代码
        }
    注意:
    1通过代码块中的锁对象，可以使用任意的对象
    2.但是必须保证多个线程使用的锁对象是同一
    3.锁对象作用
        把同步代码块锁住，只让一个线程在同步代码块中执行
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;
    //创建一个锁对象
    Object obj =new Object();

    /*
        静态的同步方法
        锁对象是谁？
        不能是this
        this是创建对象之后产生的，静态方法优先于对象
        静态方法的锁对象是本类的class属性 Class文件对象(反射)
    */
    public static /*synchronized*/ void payTicket() {
        synchronized (RunnableImpl.class) {
            if (ticket > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
    /*public static synchronized void payTicket(){
        //synchronized (this){
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
    }*/
    //}
    @Override
    public void run(){
        System.out.println("this:"+this);
        while (true){
           payTicket();
        }
    }
    /*
    定义一个同步方法
    同步方法也会把方法内部的代码锁住
    只让一个线程执行
    同步方法的锁对象是谁？
    就是实现类对象new RunnableImpl()
    也就是this
     */
    /*public *//*synchronized*//* void payTicket(){
        synchronized (this){
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }*/

}

/*
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }
}

2.5 Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock():加同步锁。
public void unlock():释放同步锁。

Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

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

/*
    卖票案例壮现了线程安全问题
    卖出了不存在的票和重复的票
    解决线程安全问题的第三种方案:使用Lock锁
    java.util.concurrent.locks
    Lock接口中的方法
        void Lock（）获取锁。
        void unlock（）释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口
    使用步骤
    1在成员位置创建一个ReentrantLock对象
    2在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
    3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;
    //1在成员位置创建一个ReentrantLock对象
    Lock l =new ReentrantLock();
    public void run() {
        while (true) {
            //2在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
            l.lock();
            if (ticket > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    //3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
                    l.unlock();//无论程序是否异常都可以释放锁
                }
            }
        }
    }
    /*@Override
    public void run(){
        while (true){
            //2在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
            l.lock();
            if (ticket > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket--;
            }
            //3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
            l.unlock();
        }
    }*/
}

/*
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }
}

第三章线程状态

3.1 线程状态概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中java.lang.Thread.State这个枚举中给出了六种线程状态：

这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

3.2 Timed Waiting（计时等待）

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。单独的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了，在哪里呢？
在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)，那么我们通过一个案例加深对该状态的一个理解。

3.3 BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。
我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。
这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，而这部分内容作为扩充知识点带领大家了解一下。
Blocked 线程状态图

3.4 Waiting（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

那么我们之前遇到过这种状态吗？答案是并没有，但并不妨碍我们进行一个简单深入的了解。我们通过一段代码来学习一下：

/*
等待唤醒案例:线程之间的通信
        创建一个顾客线程（消费者）:告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到 WAITING状态（无限等待）
        创建一个老板线程（生产者）:花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子
        注意:
            老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
            同步使用的锁对象必须保证唯一
            只有锁对象才能调用wait和notify方法
        Obejct类中的方法
        void wait
            在其他线程调用此对象的 notify（）方法或 notifyALL（）方法前，导致当前线程等待。
        void notify
            唤醒在此对象监视器上等待的单个线程。
            会继续执行wait方法之后的代码
 */
public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while (true) {
                    //保证等待和唤醒只能有一个在执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("告知老板要的包子种类和数量");
                        //调用wait方法，放弃cpu的执行，进入到 WAITING状态（无限等待）
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，开吃");
                        System.out.println("========================");
                    }
                }
            }
        }.start();
        //创建一个老板线程（生产者）
        new Thread(){
            @Override
            public void run() {
                //一直等着做包子
                while (true) {
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒只能有一个在执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("告知顾客可以吃包子");
                        //做好包子之后，调用notify方法，唤醒顾客吃包子
                        obj.notify();
                    }
                }
            }
        }.start();

    }

}

3.5 Object类中wait带参方法和notify

/*
进入到 Timewaiting（计时等待）有两种方式
1.使用Sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到 Runnable/Blocked状态
2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

唤醒的方法:
void notify（）唤醒在此对象监视器上等待的单个线程
void notifyAll（）唤醒在此对象监视器上等待的所有线程
 */
public class Demo02WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while (true) {
                    //保证等待和唤醒只能有一个在执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("告知老板要的包子种类和数量");
                        //调用wait方法，放弃cpu的执行，进入到 WAITING状态（无限等待）
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，佩奇开吃");
                        System.out.println("========================");
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while (true) {
                    //保证等待和唤醒只能有一个在执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("告知老板要的包子种类和数量");
                        //调用wait方法，放弃cpu的执行，进入到 WAITING状态（无限等待）
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，乔治开吃");
                        System.out.println("========================");
                    }
                }
            }
        }.start();
        //创建一个老板线程（生产者）
        new Thread(){
            @Override
            public void run() {
                //一直等着做包子
                while (true) {
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒只能有一个在执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("告知顾客可以吃包子");
                        //做好包子之后，调用notify方法，唤醒顾客吃包子
                        obj.notifyAll();
                    }
                }
            }
        }.start();
    }
}