12.JAVA之线程、锁、设计模式

最新推荐文章于 2024-08-23 15:54:50 发布

太彧

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量65

点赞数

文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/weixin_56027329/article/details/130163517

版权

本文介绍了Java中的多线程概念，包括线程的状态、创建方式（继承Thread和实现Runnable接口）、同步锁（synchronized）以及线程池的应用。此外，还讨论了单例模式的饿汉式和懒汉式实现。

摘要由CSDN通过智能技术生成

一、多线程

1，概述
进程是指正在运行的程序。

线程是被包含在进程里。是操作系统能够调度的最小单位，也是实际的运作单位。

一个软件的运行需要依赖至少一个进程。

一个进程的运行需要依赖至少一个线程。

单线程是有1个线程，效率低。多线程拥有>1的线程数，来提高效率。

2、多线程的特性

2.1、随机性

2.2线程状态

线程生命周期，总共有五种状态：

1) 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()。

2) 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行。

3) 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中。

4) 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态

5) 根据阻塞产生的原因不同，阻塞状态又可以分为三种：

a) 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态。

b) 同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。

c) 其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

6) 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

1.1进程

1.1.1概述

就是正在运行的程序。也就是代表了程序锁占用的内存区域。

1.1.2特点

独立性：进程是系统中独立存在的实体，它可以拥有自己的独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。

动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念，进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的。

并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

1.2线程

1.2.1概述

线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程可以开启多个线程。

多线程扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。

简而言之，一个程序运行后至少一个进程，一个进程里包含多个线程。

如果一个进程只有一个线程，这种程序被称为单线程。

如果一个进程中有多条执行路径被称为多线程程序。

1.2.2进程和线程的关系

从图中可以看出一个操作系统中可以有多个进程，一个进程中可以有多个线程，每个进程有自己独立的内存，每个线程共享一个进程中的内存，每个线程又有自己独立的内存。（记清这个关系，非常重要！）

所以想使用线程技术，得先有进程，进程的创建是OS创建的，你能实现吗？不能，一般都是c或者c++语言完成的。

二、多线程创建：继承Thread

2.1概述

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。Start()方法是一个native方法，它将通知底层操作系统，最终由操作系统启动一个新线程，操作系统将执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。

模拟开启多个线程，每个线程调用run()方法。

2.2常用方法

package cn.tedu.util;
//测试Thread工具类
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread();
        System.out.println(t.getId());//获取线程的id
        t.setName("王林");//设置线程名称
        System.out.println(t.getName());//获取线程的名字
        t.run();//运行
        t.start();//开启线程
        t.stop();//结束线程
        Thread.sleep(100);//使线程休眠//静态方法12和13行
        Thread t1 = Thread.currentThread();//获取正在执行的线程对象
        System.out.println(t1.getName());//获取正在执行任务的线程的名字
        System.out.println(Thread.currentThread().getName());
    }
}

2.3模拟多线程

package cn.tedu.util;
//测试  模拟多线程编程
public class Test4 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new MyThread().start();//启动线程
//        new MyThread().run();//没有多线程的效果
            //start()--1,启动线程--2,找到线程类的run()运行
            //new MyThread() --线程是新建状态
            //start() -- 从新建状态变成可运行状态(等着CPU选中)
        }
//        Thread-1=9//MyThread m = new MyThread();
//        Thread-0=0//m.run();//m.start();
//        这种方法不会出现上面注释的0和1，会全部都是0
    }

}
class MyThread extends Thread{
    @Override
    public void run(){//使线程从可运行状态变换成运行状态
        for (int i = 0; i < 4; i++) {
            System.out.println(super.getName()+"="+i);
        }
    }//使线程从运行状态变换成 终止状态
}

三、多线程创建：实现Runnable接口

3.1概述

如果自己的类已经extends另一个类，就无法多继承，此时，可以实现一个Runnable接口。

3.2常用方法

package cn.tedu.util;

public class Test5 {
    public static void main(String[] args) {
        MyRunnable target = new MyRunnable();
//        Thread t = new Thread(target);//绑定目标类和Thread类的关系
//        t.start();
//        Thread t1 = new Thread(target);//绑定目标类和Thread类的关系
//        t1.start();
//        new Thread(target).start();
        for (int i = 0; i < 4; i++) {
            Thread t = new Thread(target);//绑定目标类和Thread类的关系
            t.start();
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"="+i);
            //利用Thread提供的静态方法currentThread()，
            // 获取正在执行任务getName()的线程名称
        }
    }
}

四、比较

五、同步锁synchronized

5.1概述

把有可能出现问题的代码包起来，一次只让一个线程执行。通过sychronized关键字实现同步。

当多个对象操作共享数据时，可以使用同步锁解决线程安全问题。

5.2语法

用在方法上：synchronized public void show(){...}

用在代码块上：锁哪+锁谁：synchronized(对象){

需要同步的代码；

}

5.3特点

1、前提1，同步需要两个或者两个以上的线程。

2、前提2，多个线程间必须使用同一个锁。

3、 同步的缺点是会降低程序的执行效率，为了保证线程安全,必须牺牲性能。

4、可以修饰方法称为同步方法，使用的锁对象是this。

5、可以修饰代码块称为同步代码块，锁对象可以任意。

实现Runable接口

package cn.yedu.util;
//测试 多线程售票
//需求：设计4个售票窗口，总计售票100张
public class Test2 {
    public static void main(String[] args) {
        MyTickets target = new MyTickets();
        for (int i = 0; i < 4; i++) {//利用4个线程执行同一个任务
            new Thread(target).start();
        }
    }
}
//创建多线程类售票 -- implements Runnable
class MyTickets implements Runnable{
    int tickets = 100;
    Object obj = new Object();
    @Override
    //1,给方法加锁,实现了同步方法,保证了访问方法时必须排队等待不抢了,保证了数据安全
    //    synchronized public void run() {
    public void run() {
        while (true){
            //2,给代码块加锁,实现同步代码块,实现了访问代码块要排队等待的效果
            //锁哪儿--从共享资源被第一次使用开始,到用完结束
            //锁对象是谁--可以任意,必须是同一个对象
            //            synchronized ("hello"){//可以
            //            synchronized (this){//可以
            //            synchronized (new Object()){//不可以
            synchronized (obj){//可以
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "~~" + tickets--);
                } else {
                    break;
                }
            }
        }
    }
}

继承Thread类

package cn.yedu.util;
//测试 多线程售票
//需求：设计4个售票窗口，总计售票100张
public class Test1 {
    public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {//用4个线程模拟4个窗口
            new Ticket().start();//启动线程
        }
    }
}
//创建多线程类售票 -- extends Thread
class Ticket extends Thread{
    static int tickets = 100;
    //2,方法可以被同步修饰,普通方法,会自动分配this对象
    //静态方法,会自动分配类名.class对象
    public void run() {
        while(true){
            //1,锁对象是谁？--如果共享资源是普通资源，锁对象可以任意
            //--如果共享资源是静态资源，锁对象必须是类名.class
            synchronized (Ticket.class){
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(super.getName() + "==" + tickets--);
                } else {
                    break;//结束死循环
                }
            }
        }
    }
}

六、线程锁

6.1悲观锁和乐观锁

1、悲观锁：还是像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态，悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁，就像synchronized，不管三七二十一，直接上了锁就操作资源了。

2、乐观锁：就像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态，乐观锁认为竞争不总是会发生，因此它不需要持有锁，将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

6.2两种常见的锁

1、 Synchronized 互斥锁（悲观锁，有罪假设）

1.1 采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

2、 ReentrantReadWriteLock 读写锁（乐观锁，无罪假设）

2.1 ReentrantLock是排他锁，排他锁在同一时刻仅有一个线程可以进行访问，实际上独占锁是一种相对比较保守的锁策略，在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生，这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题，如果”读/读”操作能够以共享锁的方式进行，那会进一步提升性能。因此引入了ReentrantReadWriteLock，顾名思义，ReentrantReadWriteLock是Reentrant（可重入）Read（读）Write（写）Lock（锁），我们下面称它为读写锁。

2.2 读写锁内部又分为读锁和写锁，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。读锁和写锁分离从而提升程序性能，读写锁主要应用于读多写少的场景。

6.3两种方式的区别

需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内！

与互斥锁相比，读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程）从理论上讲，与互斥锁定相比，使用读-写锁允许的并发性增强将带来更大的性能提高。

6.4自旋

很多synchronized里面的代码只是一些很简单的代码，执行时间非常快，此时等待的线程都加锁可能是一种不太值得的操作，因为线程阻塞涉及到用户态和内核态切换的问题。既然synchronized里面的代码执行得非常快，不妨让等待锁的线程不要被阻塞，而是在synchronized的边界做忙循环，这就是自旋。如果做了多次忙循环发现还没有获得锁，再阻塞，这样可能是一种更好的策略。

While(true) {

synchronized (this) {

if(ticket<=0) {

break;

}

System.out.println(“窗口：” + Thread.currentThread().getName()

+”, 剩余票数：” + ticket-- );

}

6.5线程创建的其他方式(线程池)

用来存放就绪状态的线程，提高线程的高可用。

两个过程：取出来+还回池里。

6.5.1ExecutorService/Executors

package cn.yedu.util;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池测试
//测试 多线程售票
//需求：设计4个售票窗口，总计售票100张
public class Test3 {
    public static void main(String[] args) {
        MyTicketss target = new MyTicketss();
        ExecutorService pool = Executors.newFixedThreadPool(4);
        //线程池：线程复用高 + 托管
        //1,创建 拥有固定大小的 线程池
        for (int i = 0; i < 4; i++) {//利用4个线程执行同一个任务
//            new Thread(target).start();//被线程池代替
//		            //2,利用池里的线程执行目标任务
            pool.execute(target);
        }
    }
}
//创建多线程类售票 -- implements Runnable
class MyTicketss implements Runnable{
    int tickets = 100;
    Object obj = new Object();
    @Override
    //1,给方法加锁,实现了同步方法,保证了访问方法时必须排队等待不抢了,保证了数据安全
    //    synchronized public void run() {
    public void run() {
        while (true){
            //2,给代码块加锁,实现同步代码块,实现了访问代码块要排队等待的效果
            //锁哪儿--从共享资源被第一次使用开始,到用完结束
            //锁对象是谁--可以任意,必须是同一个对象
            //            synchronized ("hello"){//可以
            //            synchronized (this){//可以
            //            synchronized (new Object()){//不可以
            synchronized (obj){//可以
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "~~" + tickets--);
                } else {
                    break;
                }
            }
        }
    }
}

6.5.2Callable/Future

package game;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test6 {

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

       ExecutorService pool = Executors.newSingleThreadExecutor();
       C1 c1 = new C1();
       //任务c1放入线程池并行执行
       Future<Double> future = pool.submit(c1);
       Double r = future.get();//获取结果
       System.out.println(r);
       pool.shutdown();//关闭任务

    }
 }
class C1 implements Callable<Double> {

    @Override
    public Double call() throws Exception {

       return Math.random();
    }
}

七、设计模式

7.1概述

单例模式可以说是大多数开发人员在实际中使用最多的，常见的Spring默认创建的bean就是单例模式的。

单例模式有很多好处，比如可节约系统内存空间，控制资源的使用。

其中单例模式最重要的是确保对象只有一个。

简单来说，保证一个类在内存中的对象就一个。

RunTime就是典型的单例设计。

饿汉式：

package cn.tedu.design;
//测试 单例模式--一个类仅有一个实例
public class Test1 {
    public static void main(String[] args) {
        Person p1 = Person.get();
        System.out.println(p1);
        Person p2 = Person.get();
        System.out.println(p2);
        //        new Person();
//        Person p = Person.get();和p1、p2一样
//        Person pp = Person.get();
        //比了地址值,相同对象得到true
        System.out.println(p1 == p2);
        //== 和 equals()的区别???
        //==比较引用类型间的地址值,比较基本类型的值本身
        //equals()默认就是==比,可以重写成比属性值
    }
}
//饿汉式
class Person{
    //1,不让外界new--私有化构造方法
    private Person(){}
    //2,自己new一个给外界准备着
    //加static ,想要被静态的方法get()调用成功,p必须也得是静态的
    static private Person p = new Person();
    //3,提供一个方法,返回p
    //加static ,get()不能通过对象调用,可以直接利用类名调用
    static public Person get(){
        return p;//把自己创建好的对象返回
    }
}

懒汉式：

package cn.tedu.design;
//测试 单例模式--一个类仅有一个实例
public class Test2 {
    public static void main(String[] args) {
        Student a = Student.get();
        Student b = Student.get();
        System.out.println(a);
        System.out.println(b);
        System.out.println( a == b);
    }
}
//懒汉式 -- 按需加载 -- 线程安全的解决方案
class Student{
    //1,私有化构造方法
    private Student(){}
    //2,给外界new一个
    //共享资源被多条语句操作了,一定有安全隐患--需要加锁
    static private Student s ;
    //3,给外界返回s --按需加载
    //静态的同步方法,自动分配的锁对象是类名.class
    synchronized static public Student get(){
        //        静态资源的锁对象必须是类名.class
        //        synchronized (Student.class) {
        if (s == null) {//没new过才new
            s = new Student();
        }
        return s;
        //        }
    }
}

八、拓展

8.1.run()和start()的区别

run()只是一个普通的方法调用，没有多线程随机的效果，不能启动线程。
start()开启线程，找到线程里的业务执行。

8.2.JVM启动是单线程还是多线程

多线程，最少要启动main线程和GC线程。

8.3.守护线程

setDaemon(true)

后台线程、守护线程。

JVM虚拟机退出条件，是所有前台线程结束，当所有前台线程结束，虚拟机会自动退出。

不会等待后台线程结束。

例如：垃圾回收器是一个后台线程。

太彧

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
12.JAVA之线程、锁、设计模式

JAVA之线程(继承Thread类、实现Runable接口)、线程池、锁(同步、异步)、线程锁、设计模式(最常见单例模式、饿汉式、懒汉式)。
复制链接

扫一扫