javaweb-线程、同步-012

lidashent

已于 2022-03-12 14:23:35 修改

阅读量330

点赞数

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

于 2020-05-16 14:12:26 首次发布

本文链接：https://blog.csdn.net/lidashent/article/details/106117467

版权

javaweb 专栏收录该内容

92 篇文章 0 订阅

订阅专栏

第一章线程

线程、同步

多线程原理_随机性打印结果

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的
start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。
多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。
当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了
当子线程启动的时候，通知jvm为其开辟新的栈空间
在这里插入图片描述

多线程原理_多线程内存图解

在这里插入图片描述
加载main主方法，压入栈中，方法调用对象，为对象在堆空间开辟空间，（方便地址访问），执行run，则在主进程中执行线程。如果有其他现成调用start,则开辟新的栈空间，多个栈空间可以由cpu选择执行，达到了多线程目的。

Thread类

即线程类,和runable线程接口略有不同

Thread类的常用方法_获取线程名称的方法

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() :返回对当前正在执行的线程对象的引用
静态方法，因此可以直接调用

创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式
下面写一个集成thread父类的线程类
获取线程的名称:
1.使用Thread类中的方法getName()
String getName() 返回该线程的名称。
2.可以先获取到当前正在执行的线程,使用线程中的方法getName()获取线程的名称
static Thread currentThread() 返回对当前正在执行的线程对象的引用。

Thread类的常用方法_设置线程名称的方法

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

Thread类的常用方法_sleep

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
毫秒数结束之后,线程继续执行

Runnable接口

创建多线程程序的第二种方式_实现Runnable接口

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程
代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。runable才是大佬

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。即是实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因
此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。
而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。
步骤如下：

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

//1.创建一个Runnable接口的实现类
public class RunableImpl implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

创建线程实现类

 RunableImpl runable = new RunableImpl();
 Thread mThread = new Thread(runable, "明世隐");
 mThread.start();

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类，实现了Runnable接口,还可以继承其他的类,实现其他的接口
增加程序的健壮性，实现解耦操作，实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用
java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

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

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

匿名:没有名字
内部类:写在其他类内部的类

匿名内部类作用:简化代码
    把子类继承父类,重写父类的方法,创建子类对象合一步完成
    把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字

格式:
    new 父类/接口(){
        重复父类/接口中的方法
    };

public class InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread
        // new MyThread().start();
        new Thread(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <5 ; i++) {
                    System.out.print(Thread.currentThread().getName()+"-->"+"1");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl();//多态
        Runnable r = new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.print(Thread.currentThread().getName()+"-->"+"3");
                }
            }
        };
        new Thread(r).start();
        /*
        * 所谓的分离，将实现与运行分开，最后由thread统一封装，实现start
        * */
        //简化接口的方式
        new Thread(new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.print(Thread.currentThread().getName()+"-->"+"3");
                }
            }
        }).start();
    }
}

第二章线程安全

对于共享资源,如果执行线程间没有交流,可能就会产生错误
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程安全问题的概述

举个栗子,卖票,票数就是共享资源,多个线程去卖票，如果不加以处理会出现票已经卖出去而其他窗口依然在卖的情况
票资源

public class Ticket {
    public static int  residueTicket=20;
}

线程消费票

public class SellTicket implements Runnable {
    Object lock=new Object();
    @Override
    public void run() {
            while (true) {
                    if(Ticket.residueTicket> 0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "卖票号" + Ticket.residueTicket--);
                }

        }
    }
}

实际情况，发现卖出去的票还在卖，甚至卖出去了没有的票

public class MyMain2 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("正在卖票，葫芦娃大战奥特曼");
        SellTicket sellTicket = new SellTicket();
        Thread daQiao = new Thread(sellTicket, "大乔");
        Thread sunCe = new Thread(sellTicket, "孙策");
        Thread liuBang = new Thread(sellTicket, "刘邦");
        daQiao.start();
        sunCe.start();
        liuBang.start();
    }
}

在这里插入图片描述

线程安全问题产生的原理

解决方法是执行的时候独占资源，待一方对资源处理完毕后再进行资源释放，不能同时享用资源

解决线程安全问题_同步代码块

卖票案例出现了线程安全问题
卖出了不存在的票和重复的票

解决线程安全问题的一种方案:使用同步代码块
格式:
    synchronized(锁对象){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
    }

注意:
    1.通过代码块中的锁对象,可以使用任意的对象
    2.但是必须保证多个线程使用的锁对象是同一个
    3.锁对象作用:
        把同步代码块锁住,只让一个线程在同步代码块中执行

public class SellTicket implements Runnable {
    Object lock=new Object();
    @Override
    public void run() {
            while (true) {
                synchronized (lock) {
                    if (Ticket.residueTicket > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "卖票号" + Ticket.residueTicket--);
                    }
                }
        }
    }
}

解决线程安全问题_同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
public synchronized void method(){
可能会产生线程安全问题的代码
}
这个同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

public class SellTicket implements Runnable {
    Object lock=new Object();
    @Override
    public void run() {
            while (true) {
                sellTicket();
        }
    }
    public synchronized void sellTicket() {
        if (Ticket.residueTicket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖票号" + Ticket.residueTicket--);
        }
    }
    public static void sellTIcket0(){
        synchronized (SellTicket.class) {

        }
    }
    public void sellTicket2() {
        synchronized (this) {
            
        }
    }
}

同理为
静态的同步方法
静态方法的锁对象是本类的class属性–>class文件对象(反射)

定义一个同步方法
同步方法也会把方法内部的代码锁住
同步方法的锁对象是谁?
就是实现类对象 new RunnableImpl()
也是就是this

Lock锁

解决线程安全问题_Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,
同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock() :加同步锁。
public void unlock() :释放同步锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口
使用步骤:
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
*/

    Lock lock1=new ReentrantLock();
    @Override
    public void run() {
            while (true) {
                lock1.lock();
                try {
                    if (Ticket.residueTicket > 0) {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + "卖票号" + Ticket.residueTicket--);
                    }
                }catch(Exception e){
                    e.printStackTrace();
                }
                finally {
                    lock1.unlock();//无论程序是否异常,都会把锁释放
                }
        }
    }

第三章线程状态

线程状态概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：
线程拥有资源未必在运行,因为未必占用cpu，只是进入了可执行状态
在这里插入图片描述

等待唤醒案例分析

Timed Waiting（计时等待）

事实上在买票案例的时候，有一个延时动作的时候已经使用了，当时加延时是为了让线程不协同的效果凸显，现在也可以理解为，一个线程执行完一个动作后开始休眠，延时之后自己又醒来了
通过案例可以发现，sleep方法的使用还是很简单的。我们需要记住下面几点：

进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
//obj.wait(5000); //计时等待, 5秒时间到，自动醒来
,wait有一个不同的属性,就是唤醒,那么便有了两个特性,如果没人叫他,他自己醒来,如果有人叫他,他立刻醒来,比sleep更加灵活
为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行。因为线程即使获得了资源，也不会立刻获得cpu的分配

BLOCKED（锁阻塞）

比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

Waiting（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法或 Object.notifyAll()方法。
其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。
当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。
/*
等待唤醒案例:线程之间的通信
创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子

注意:
    顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行
    同步使用的锁对象必须保证唯一
    只有锁对象才能调用wait和notify方法

Obejct类中的方法
void wait()
      在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
void notify()
      唤醒在此对象监视器上等待的单个线程。
      会继续执行wait方法之后的代码

*/
如下，使用了同一个线程锁，用来控制等待和唤醒

public class MyMain3 {
    public static void main(String[] args) {
        Object lock = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    synchronized (lock) {
                        System.out.println(Thread.currentThread().getName() + ":告诉要吃什么包子");
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "吃完了");
                        lock.notify();

                    }
                }
            }
        }, "顾客").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    synchronized (lock) {
                        System.out.println(Thread.currentThread().getName() + ":做好了，请吃");
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "老板").start();

    }
}

Object类中wait带参方法和notifyAll方法

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

唤醒的方法:
     void notify() 唤醒在此对象监视器上等待的单个线程。
     void notifyAll() 唤醒在此对象监视器上等待的所有线程。

*/
创建加载在此锁上的线程，obj


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("顾客1告知老板要的包子的种类和数量");
                        //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了,顾客1开吃!");
                        System.out.println("---------------------------------------");
                    }
                }
            }
        }.start();

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

        //创建一个老板线程(生产者)
        new Thread(){
            @Override
            public void run() {
                //一直做包子
                while (true){
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);//花5秒钟做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
                        //做好包子之后,调用notify方法,唤醒顾客吃包子
                        /*
                        * ——————————————————————————————————————————————
                        * */
                        //obj.notify();//如果有多个等待线程,随机唤醒一个
                        obj.notifyAll();//唤醒所有等待的线程
                    }
                }
            }
        }.start();
    }
}

比如Waiting（无限等待）状态中wait方法是空参的，而timed waiting（计时等待）中wait方法是带参的。
这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是
如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两
得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；如果在倒
计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。