线程he 工厂模式

最新推荐文章于 2023-07-19 09:51:54 发布
最新推荐文章于 2023-07-19 09:51:54 发布
阅读量337 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pershinggeng/article/details/117388061
版权

进程:由系统资源分配和调度的最小单元,而线程依赖于进程存在,程序执行的最小单位!

如果创建线程----必须有进程----->创建系统资源
 * Java语言不能够创建系统资源, 借助于底层语言C语言来操作
 *  Java提供类Thread类
 *
 * 借助于Thread类如何实现 线程的创建?
 *
 *
 * 并发:在一个时间点同时发生
 * 并行:在一个时间段内同时发生
 *
 *
 * 开发步骤:
 *  1)自定义一个类 继承自 Thread(线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。 )
 *  2)该子类应重写 Thread 类的 run 方法
 *  3)创建当前子类对象,然后启动线程:start()而非run方法()
 *
 *  启动线程:使用start 方法
 *成员方法:
 *  设置线程名称
 *          public final void setName(String name)
 *  获取线程名称:
 *          public final String getName()

public class ThreadDemo {

    public static void main(String[] args) {

        //创建子类对象
        MyThread my = new MyThread() ;

        //启动线程
        //这个一线程对象将run方法调用两次
      //  my.run();
      //  my.run();

        my.setName("杨德财");
        my.start(); //调用start方法,是通过jvm调用run方法
        //my.start(); //IllegalThreadStateException:非法状态异常

        MyThread my2 = new MyThread() ;
        my2.setName("高圆圆") ;
        my2.start();
    }
}

 public static void yield():暂停当前正在执行的线程,执行其他线程!

public final void join()
 *                 throws InterruptedException  :等待该线程终止

Thread类的常量字段表
 * public static final int MAX_PRIORITY 10
 *  public static final int MIN_PRIORITY 1
 *  public static final int NORM_PRIORITY 5  :默认值
 *
 *  public final void setPriority(int newPriority)设置优先级
 *  public final int getPriority()
 *
 *
 *  优先级越大的线程,抢占CPU的执行权(cpu一点点时间片,可以高效的进行切换)的资格大
 *  优先级越小的线程:抢占CPU的执行权越小!
 *
 *  线程的执行具有随机性!默认是5

tp1.setPriority(10);
        tp2.setPriority(1);
        System.out.println(tp3.getPriority());//5

Java语言不能开启多线程

.什么是进程,什么是线程
    进程:  
        系统资源分配和调度的基本单元! (程序的"实体")
    线程必须依托于进程存在,是程序执行的基本单位!    
    一个进程有有很多个线程组组成的,一个线程组中包含很多线程(是线程的集合!)
    
    多线程---每个线程的执行具有随机性,在互相强制CPU的执行权(才具备执行资格)

2.创建多线程的方式?请阐述步骤
        方式1:
            使用继承关系:
            1)自定义一个类,继承自Thread类(线程类)
            2)重写run方法: 通过启动线程,jvm调用run方法
            3)在用户线程(main)创建当前类对象,启动线程:start()

3.Map集合的遍历方式
        两种
            1)获取所有的键的集合:Set<K> keySet()  (推荐)
                    遍历所有的键---V get(Object K):通过键获取值
                    
            2)获取所有的键值对对象:Set<Map.entry<K,V>> entrySet() 
                        遍历所有键值对对象:通过键值对对象:获取键和值
                                K getKey()
                                V getValue()

4.自然排序和比较器排序在TreeSet<E>集合中如何实现
        如果TreeSet<E>要实现自然排序,通过无参构造方法创建当前类对象TreeSet<E>() 
        必须满足条件:当前存储的类型必须实现接口Comparable接口  
        重写comparable接口中的compareTo(T t)方法
        
        如果TreeSet<E>实现比较器排序:通过有参构造创建当前类对象TreeSet<E>(Comparator<E> com)
        
        1)自定义类实现Comparator<E>,重写Comparator接口的compare(T t1,T t2) 
        2)创建当前类对象的时候,直接使用接口匿名内部类的方式
           形式参数:
                    new Comparator<E>(){
                            重写compare(T t1,T t2) {
                                    排序规则
                            }
                    } ;

5.final,finalize的区别?
        final:状态修饰符
        修饰类,不能被继承
        修饰方法:不能被重写
        修饰变量:是一个常量
        
        
        finalize:是Object类的一个方法:当前创建对象的时候,如果这个对象没有更多引用,使用完毕了,
        等待GC来回收不用的对象,启动GC,会调用finalize()方法来回收,释放被占用的空间!
        
        
        
        GC垃圾回收算法
        JVM优化机制
        
        
        SQL优化(SQL调优)
        web服务器调优

多线程实现方式1:   继承关系
     SellTicket st1 = new SellTicket() ;
            SellTicket st2 = new SellTicket() ;
            SellTicket st3 = new SellTicket() ;

            //设置线程名称
            st1.setName("窗口1") ;
            st2.setName("窗口2") ;
            st3.setName("窗口3") ;

            //启动线程
            st1.start() ;
            st2.start() ;
            st3.start();

            三个栈指向三个堆:分别在出售100张票 "没有数据共享"
继承关系具有局限性--->重写run方法----->Thread类的run---->通过实现Runnable接口的run 方法
    不仅仅继承run方法,还将其他无关方法继承过来,不利于功能的扩展! (体现不出来:面向接口编程)



多线程实现方式2: (推荐)
            "资源共享"
            每一个线程都在使用同一个对象 st(SellTicket对象的引用) 体现出 "面向接口编程"
            静态代理 模式
                    最大特点:真实角色和代理类都必须实现同一个接口!
                    代理类 对真实角色的功能进行方法增强!
            代理类
            真实角色

            SellTicket 实现Runnable接口 完成run方法重写
            Thread类 本身实现Runnable接口 完成run方法重写



                 SellTicket st = new SellTicket() ;
                //创建多个线程类对象,将资源共享类作为参数传递
                Thread t1 = new Thread(st,"窗口1") ;
                Thread t2 = new Thread(st,"窗口2") ;
                Thread t3 = new Thread(st,"窗口3") ;



                //启动线程
                t1.start();
                t2.start();
                t3.start();

多线程的实现方式2   实现关系(Runnable)  (重点)


 *
 * 步骤:
 *  1)自定义一个类,实现Runnable接口,重写run方法
 *  2)在用户线程(main)创建当前"资源类"对象
 *   然后创建Thread类对象,将"资源类"对象作为参数传递
 *
 *  public Thread(Runnable target,String name)
 *  3)分别启动线程
 *
 *
 *  //Thread类的静态功能
 *  public static Thread currentThread():表示正在执行的线程对象的引用

public class ThreadDemo {
    public static void main(String[] args) {

        //创建资源类对象
        MyRunnable my = new MyRunnable() ;//共享资源

        //创建线程类对象
        Thread t1 = new Thread(my,"t1") ;
        Thread t2 = new Thread(my,"t2") ;
        Thread t3 = new Thread(my,"t3") ;

        //启动线程
        t1.start();
        t2.start();
        t3.start();


    }


}
实现runnable接口
public class MyRunnable implements  Runnable{

电影院有三个窗口,总共100张票,使用多线程模拟!

public class SellTicket  extends  Thread{

    //有100张票
    public static int tickets = 100 ;
    //创建一个把锁
    private Object obj = new Object() ;

    @Override
    public void run() {
        //模拟一直有票
        while(true){
            synchronized (obj){
                //加入网络延迟,睡眠100毫秒
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(tickets>0){
                    System.out.println(getName()+"正在出售第"+tickets+"张票");
                    tickets -- ;
                }else{
                    break ;
                }
            }


        }
    }
}
public class SellTicketDemo {

    public static void main(String[] args) {

        //创建三个线程
        SellTicket st1 = new SellTicket() ;
        SellTicket st2 = new SellTicket() ;
        SellTicket st3 = new SellTicket() ;

        //设置线程名称
        st1.setName("窗口1") ;
        st2.setName("窗口2") ;
        st3.setName("窗口3") ;

        //启动线程
        st1.start() ;
        st2.start() ;
        st3.start();
    }
}

v

线程的执行:具有"原子性操作": tickets--   (线程的随机性导致的)
            //t1先进来, 记录以前的值:100
            //在t1记录100数据的时候,准备--的时候,t2进来,可能将t1之前记录的100值输出,100 出现同票

            //第二种情况:出现了负票
            //当前t1线程---第2张票
            //睡眠100毫秒
            //t3线程抢占到--->(将t1线程的2记录---完成--)第1张票
            //t1,t2,t3 ---->t2先抢占到 ---->记录之前1,--完成后,变成0张票
            //当前内存中记录值还没输出0的时候,t1抢占到之后,记录t2记录0张票, t1的票数--,   出现-1

第二种方式能够体现  "资源共享"
 *
 * 程序出现:
 *      1)一个张票可能被卖多次(出现同票)
 *              线程的执行具有随机性(原子性操作:最简单,最基本的操作语句:--,++...)
 *      2)出现了负票
 *             线程的延迟性导致(加入睡眠100毫秒)
 *      现在的程序存在 "多线程安全问题"

public class SellTicketDemo {
    public static void main(String[] args) {


        //创建资源共享类对象
        SellTicket st = new SellTicket() ;
        //创建多个线程类对象,将资源共享类作为参数传递
        Thread t1 = new Thread(st,"窗口1") ;
        Thread t2 = new Thread(st,"窗口2") ;
        Thread t3 = new Thread(st,"窗口3") ;

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

现在的程序虽然能够体现"资源共享",程序出负票和同票,如何解决安全问题?
 *
 *    校验多线程安全问题的标准是什么?
 *
 *    1)查看当前程序是否是多线程环境      是
 *    2)是否存在共享数据                    是 tickets
 *    3)是否有多条语句对共享数据进行操作   存在
 *
 *
 *    1),2)都必须具备:现在使用的就是多线程环境,而且存在共享数据
 *
 *
 *    从3)入手
 *          Java提供一个同步机制:将多条语句对共享数据操作的使用同步代码块包括起来
 *                  格式:
 *                          synchronized(锁对象){ //多个线程必须使用的同一把锁 (可以任意的Java类对象)
 *                              将多条语句对共享数据操作
 *                          }

共享资源类
 *
 * synchronized:关键字---- 内置语言实现的(jvm来实现锁定操作: 锁的释放:自动释放)
 *      可以是通过代码块(代码中),可以在方法上使用(同步方法)
 *          synchronized同步锁---属于"悲观锁"
 *                      悲观锁:自己线程本身在执行的时候,其他线程不能进入同步代码块中,其他线程不能进入
 *                      修改数据,保证数据的安全性!  (针对频繁的写入操作)

public class SellTicket implements Runnable {
    public static int tickets = 100 ;//100张票

    private Demo demo = new Demo();
   // private Object obj = new Object() ;


    //t1,t2,t3
    @Override
    public void run() {
        //为了模拟一直有票
        while(true){
        //t1,t2,t3
            //加入同步代码块
            //把它理解为:门的开/关
//            synchronized(new Object()){ //三个线程有自己的锁对象


            //t1进来,t2和t3没有办法进入的
           // synchronized(obj){ //一个锁对象
            //锁对象可以是任意的Java类对象
            synchronized(demo){ //一个锁对象
                if(tickets>0){  //t1进来
                    //睡眠100毫秒
                    //为了模拟网络延迟
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+
                            "正在第"+(tickets--)+"张票");
                }
            }
        }
    }
}

//自定义的类
class Demo{

}

public class SellTicket implements Runnable {

    //100张票
    public static int tickets = 100 ;

    //声明一个锁:Lock
    private Lock lock = new ReentrantLock() ;

    @Override
    public void run() {
        //模拟一直有票
        while(true){

            //获取一个锁:某个线程执行到这块:必须持有锁
            lock.lock();

            //执行完毕,手动释放锁
            //在开发中 :try...catch...finally :捕获异常 ,不会使用throws
            //变形格式:try...catch...catch...
            //try...finally...
            try{
                if(tickets >0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
                }
            }finally {
                //释放资源代码块
                //释放锁
                lock.unlock();
            }

 

1.1什么是锁？

      在计算机科学中，锁(lock)或互斥(mutex)是一种同步机制，用于在有许多执行线程的环境中强制对资源的访问限制。锁旨在强制实施互斥排他、并发控制策略。

      锁通常需要硬件支持才能有效实施。这种支持通常采取一个或多个原子指令的形式，如"test-and-set", "fetch-and-add" or "compare-and-swap"”。这些指令允许单个进程测试锁是否空闲，如果空闲，则通过单个原子操作获取锁。

1.2.锁的一个重要属性 粒度 Granularity [grænjʊ‘lærɪtɪ]

在引入锁粒度之前，需要了解关于锁的三个概念：

1、锁开销 lock overhead 锁占用内存空间、 cpu初始化和销毁锁、获取和释放锁的时间。程序使用的锁越多，相应的锁开销越大

2、锁竞争 lock contention 一个进程或线程试图获取另一个进程或线程持有的锁，就会发生锁竞争。锁粒度越小，发生锁竞争的可能性就越小

3、死锁 deadlock 至少两个任务中的每一个都等待另一个任务持有的锁的情况锁粒度是衡量锁保护的数据量大小，通常选择粗粒度的锁(锁的数量少，每个锁保护大量的数据)，在当单进程访问受保护的数据时锁开销小，但是当多个进程同时访问时性能很差。因为增大了锁的竞争。相反，使用细粒度的锁(锁数量多，每个锁保护少量的数据)增加了锁的开销但是减少了锁竞争。例如数据库中，锁的粒度有表锁、页锁、行锁、字段锁、字段的一部分锁

相关术语  Critical Section(临界区)、 Mutex/mutual exclusion(互斥体)、 Semaphore/binary semaphore(信号量)

2.锁的种类

2.1.独享锁/共享锁

独享锁是指该锁一次只能被一个线程所持有。 (ReentrantLock、 Synchronized)

共享锁是指该锁可被多个线程所持有。 (ReadWriteLock)

互斥锁/读写锁

独享锁/共享锁这是广义上的说法，互斥锁/读写锁就分别对应具体的实现。在Java中如ReentrantLock就是互斥锁(独享锁)， ReadWriteLock就是读写锁(共享锁)。 独享锁与共享锁也是通过AQS来实现的

锁升级：读锁到写锁 (不支持)

锁降级：写锁到读锁 (支持)

2.2.读写锁 ReentrantReadWriteLock

低16位代表写锁，高16位代表读锁
————————————————
版权声明：本文为CSDN博主「blackbeilei」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u010648018/article/details/79750608

      
    

公平锁/非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁。

非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能会造成饥饿现象。

对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的控制线程对锁的获取， 所以并没有任何办法使其变成公平锁。
————————————————
版权声明：本文为CSDN博主「blackbeilei」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u010648018/article/details/79750608

可重入锁

可重入锁又名递归锁，是指同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取.

如上面的代码，如果synchronized不是可重入锁的话，testB就不会被当前线程执行，从而形成死锁。

 

需要注意的是，可重入锁加锁和解锁的次数要相等。

C==0表明未获得锁，Else表示已经获得锁，这时对state加1，相应的，每次释放锁都会对state减1

2.4.乐观锁/悲观锁

乐观锁/悲观锁不是指具体类型的锁，而是看待并发的角度。

悲观锁认为存在很多并发更新操作，采取加锁操作，如果不加锁一定会有问题

乐观锁认为不存在很多的并发更新操作，不需要加锁。数据库中乐观锁的实现一般采用版本号，Java中可使用CAS实现乐观锁。

2.5.分段锁

分段锁是一种锁的设计，并不是一种具体的锁。对于ConcuttentHashMap就是通过分段锁实现高效的并发操作。
————————————————
版权声明：本文为CSDN博主「blackbeilei」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u010648018/article/details/79750608

自旋锁

自旋锁是指尝试获取锁的线程不会阻塞，而是采用循环的方式尝试获取锁。好处是减少上下文切换，缺点是一直占用CPU资源。

.偏向锁/轻量级锁/重量级锁

这是jdk1.6中对Synchronized锁做的优化，首先了解下对象头(Mark Word)：

运行时JVM内存布局

原文链接：https://blog.csdn.net/u010648018/article/details/79750608


 * 虽然syncrhonized可以解决线程安全问题:同步代码块/同步方法,但是执行效率低,可能出现死锁
 *      两个线程或者多个线程出现互相等待的情况!

解决死锁问题方案:"生产者消费者思想" 必须保证多个多线程必须使用的同一个资源对象!

public class DieLockDemo {

    public static void main(String[] args) {

        //创建资源类对象
        DieLock dl1 = new DieLock(true) ;
        DieLock dl2 = new DieLock(false) ;

        //创建线程类对象
        Thread t1 = new Thread(dl1) ;
        Thread t2 = new Thread(dl2) ;

        //启动线程
        t1.start();
        t2.start();
        /**
         *   if(flag){
         *             synchronized (MyDieLock.objA){
         *                 System.out.println("if objA");
         *                 synchronized (MyDieLock.objB){
         *                     System.out.println("if objB"); //需要等待第二个线程 objB释放锁掉
         *                 }
         *             }
         *         }else{
         *             synchronized (MyDieLock.objB){
         *                 System.out.println("else objB");
         *                 synchronized (MyDieLock.objA){
         *                     System.out.println("else objA");//需要等待第一个线程 将objA锁释放掉
         *                 }
         *             }
         *         }
         *
         *
         * 情况1:
         * if objA
         * else objB
         *
         * 当第一个ObjA锁被使用,输出"if objA"
         * 同时第二个线程dl2: ObjB锁被使用 "else objB"
         *
         *
         * 情况2:
         * else objB
         * if objA
         *
         *
         * 情况3:理想情况:
         * if objA
         *      if objB
         *  else objB
         *      else objA
         */
    }
}
public class MyDieLock {

    //创建两把锁对象 (静态实例变量)
    public static final Object objA = new Object() ;
    public static final Object objB = new Object() ;
}

测试类
 *      SetThread:生产数据
 *      GetThread:消费数据
 *      Student:学生数据
 *
 *
 *      问题1 :出现数据 null--0 :
 *
 *      在生产资源类和消费者资源类中:分别new Student() :不是同一个对象
 *
 *
 *
 *      模拟一直有数据:加入循环操作while(true)
 *
 *      问题2:姓名和年龄不符
 *      线程的执行具有随机性导致,多线程程序不安全
 *
 *
 *      校验多线程安全问题的标准是什么?
 *          1)查看是否是多线程环境
 *          2)是否存在共享数据
 *          3)是否有多条语句对共享数据进行操作
 *
 *
 *          3)改进:使用同步代码块包括起来!
 *
 *
 *
 *          问题3:学生数据输出的时候,一次性打印很多
 *                  线程的一点点时间片:足够当前线程执行很多次!
 *
 *          优化:
 *          不需要输出学生数据的时候, 一次性输出很多,而是分别依次输出
 *                  "高圆圆" 41
 *                  "杨德财" 27

public class ThreadDemo {

    public static void main(String[] args) {

        Student s = new Student() ; //同一个资源类对象
        //创建生产资源类对象
        SetThread st = new SetThread(s) ;
        //创建消费者资源类对象
        GetThread gt = new GetThread(s) ;

//        创建线程类对象
        Thread sThread = new Thread(st) ;
        Thread gThread = new Thread(gt) ;

        //启动
        sThread.start();
        gThread.start();

    }
}
@Version 1.0
 * 生产者资源类
 */
public class SetThread implements  Runnable {

    private Student s ;
    public SetThread(Student s){
        this.s =  s ;
    }

    //统计变量
    int x = 0 ;
    @Override
    public void run() {

        //不断产生数据
        while(true){

            synchronized (s){
                //判断如果当生产者有数据
                if(s.flag){
                    try {
                        //生产者有数据,需要等待消费者线程使用
                        s.wait(); //锁对象在调用wait()
                        //wait():当前锁对象该调用方法的时候,会立即是否锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //当前在执行下面代码的之前:线程的执行资格被GetThread所在的消费者线程
                if(x % 2 == 0){
                    s.name  = "高圆圆" ;
                    s.age = 41 ;

                }else{
                    s.name = "杨德财" ;
                    s.age = 27 ;
                }
                x ++ ;


                //更改标记
                s.flag = true ;
                //通知对方线程:赶紧使用数据
                s.notify(); //锁对象调用的唤醒方法


            }

        }
       // Student s = new Student();

    }
} 
消费者资源类
public class GetThread implements Runnable {

    private Student s ;
    public GetThread(Student s){
        this.s = s ;
    }

    @Override
    public void run() {

        //模拟一直消费数据
        while(true){

            synchronized (s){
                if(!s.flag){
                    //如果消费者没有数据了,需要等待生产线程产生数据
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.println(s.name+"---"+s.age);

                //更改标记
                s.flag = false ;//没有数据了
                //通知对方线程:生产线程 :产生数据
                s.notify() ;

            }

        }


       // Student s = new Student() ;

    }
}
public class Student {

    String name ;
    int age ;

    //是否存在学生数据标记
    boolean flag ; //true有数据,false没有数据

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

1.创建多线程的方式有几种
    三种
        1)继承关系:
            自定一个类继承自Thread类
            重写Thread类的run方法
            在main中创建当前类对象,启动线程调用start()
        2)实现Runnable接口
            自定义一个类 实现Runnable接口
            重写Runnable接口的run方法
            在main中将自定义的类作为资源共享类---创建当前类对象 
            创建线程类Thread类对象,将资源共享类作为参数传递
            分别启动线程调用start()
            
        3)线程池    

2.获取一个类的字节码文件有几种方式?
        三种
            1)Object类的getClass()方法
            2)任意Java类型的class属性
            3)反射:Class.forName("包名.类名") ;

3.wait方法和sleep方法的区别(经常会的)
    1)是否释放锁
        当锁对象调用wait方法,立即释放锁;
        而sleep(xx):被调用的时候,线程一直处于阻塞状态,不会释放锁
    
    2)来源不同
        wait()来源于Object类----- >跟锁对象关系!
                为什么将wait():线程等待  ;notify()  notifyAll() 线程唤醒,定义Object类中?
                因为这些方法和锁有关系,而锁对象可以是任意Java对象!
        sleep():来源于Thread类---->只是属于一种状态,跟锁无关
    
    3)他们都会抛出interruptedException:当前状态被中断,都会抛出异常!

4.线程的状态有几种?
    6中
        Thread类枚举类State
            NEW
            RUNNABLE
            BLOCKED
            WAITTING
            TIMED_WAITTING
            TERMINATED

5.什么是静态代理?请描述   
            静态代理:就是代理类和真实角色都需要实现同一个接口
                    代理类:帮助真实角色完成业务功能的增强
                    真实角色:专注于自己的事情
                    
                    //代理角色
                    Thread类 implements Runnable{
                    
                            private Runnable target ;
                            
                            public void run(){
                                if(target!=null){
                                    target .run() ;
                                }
                            }
                    }
                    //真实角色
                    MyRunnable implements Runnable{
                        //业务逻辑:完成多个线程在互相并发执行过程中抢占CPU执行权(数据)
                        public void run(){
                            ...
                        }
                    }

6.如何解决线程安全问题?
        同步机制:悲观锁(synchronized)                
                使用同步代码解决线程安全问题: 加了同步锁,其他线程不能更改它数据(针对频繁写入操作)
                synchronized(锁对象){
                        多条语句对共享数据操作;
                }
                
                同步方法
                public synchronized 返回值类型 方法名(形参列表){  //锁对象:this
                    ...
                }
        
        Mybatis框架---->Mybatis-Plus (插件可以使用乐观锁)
                                                                


7.什么是Java中的等待唤醒机制?

        等待唤醒机制---称为"等待通知",习惯于叫等待唤醒
        当前多个线程出现循环等待-----死锁
        使用notify() notifyAll()  将阻塞状态中线程进行唤醒,来操作业务数据!
        多个线程必须使用的是同一个资源对象!

 创建型设计模式:对象的创建
 * Java提供:简单工厂模式 ---静态工厂方法模式
 * 优点:不需要具体类创建具体实例,通过工厂类创建
 *
 * 弊端:一旦有一个新的类型增,修改工厂类!
 *
 * 需要提供一个工厂类,负责具体的实例的创建

public class Test {

    public static void main(String[] args) {

        //创建猫
        Cat cat = new Cat() ;
        cat.eat();
        cat.sleep();
        //狗
        Dog dog = new Dog() ;
        dog.eat();
        dog.sleep();

        System.out.println("------------------------");

        //提供工厂类创建具体的动物实例
       /* Cat c1 = AnimalFactory.createCat();
        c1.eat();
        c1.sleep();
        Dog d = AnimalFactory.createDog() ;
        d.eat();
        d.sleep();*/

       //优化之后
        Animal animal = AnimalFactory.createAnimal("dog"); //父类引用指向子类对象
        animal.eat();
        animal.sleep();
        animal = AnimalFactory.createAnimal("cat") ;
        animal.eat();
        animal.sleep();
    }

}
public class Animal {

    public void eat(){
        System.out.println("动物都需要吃");
    }
    public void sleep(){
        System.out.println("动物都需要休息");
    }
}
public class AnimalFactory {
    //构造方法私有化
    private AnimalFactory(){ //外界不能创建当前类对象

    }

    //静态方法
    //创建猫的实例
 /*   public static Cat createCat(){

        return new Cat() ;
    }

    //创建狗的实例
    public static Dog createDog(){
        return new Dog() ;
    }




    //创建猪的实例
    public static Pig createPig(){
        return new Pig() ;
    }*/

 //优化:利用多态:提供功能扩展
    public static Animal createAnimal(String type){
        if(type.equals("dog")){
            return new Dog() ;
        }else if(type.equals("cat")){
            return new Cat() ;
        }else if(type.equals("pig")){
            return new Pig() ;
        }else{
            System.out.println("对不起,工厂类没有提供者动物的实例创建!");
        }
        return null ;
    }

}
public class Cat extends  Animal {


        public void eat(){
            System.out.println("i can eat and eat mouse");
        }

        public void sleep(){
            System.out.println("i can sleep ...");
        }

}
public class Dog  extends  Animal{

    public void eat(){
        System.out.println("i can eat and eat meat");
    }
    public void sleep() {
        System.out.println("i can sleep");
    }

}

工厂方法模式:
 *
 *      对象创建的工作:有一个接口完成
 *      接口的子实现类---->创建具体实例的工厂类
 *
 *      优点:面向接口编程:  结构非常清晰,维护起来容易
 *
 *      弊端:代码量增加了,需要编写额外的工厂类...

public class Test {
    public static void main(String[] args) {

        //没有使用工厂方法模式
        //抽象类多态
        Animal a = new Cat();
        a.eat();
        a = new Dog() ;
        a.eat();

        System.out.println("-----------------------------------");

        //猫的工厂类
        Factory f = new CatFactory() ;
        Animal animal = f.createAnimal(); //new Cat()
        animal.eat();


        f = new DogFactoy() ;
        Animal an = f.createAnimal();
        an.eat();

    }
}
public interface Factory { //工厂接口


    //创建动物的实例
    public abstract Animal  createAnimal() ;
}
public class DogFactoy implements Factory {

    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}
public  abstract  class Animal {

    public abstract  void eat() ;//吃
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

创建型设计模式之单例
 *
 * 单例:
 *      在加载某个类的时候,内存中始终只有一个对象!(该类对象自动创建)
 *
 *      两种:
 *          饿汉式:特点  永远不会出现问题的单例模式!
 *              在加载这个类的时候,就已经在内存中创建了一个对象!
 *              1)自定义一个类(具体类)
 *              2)成员位置:创建当前类的实例
 *              3)提供私有的构造方法:外界不能够创建它
 *              4)对外提供公共的访问方法:静态的,返回值当前类本身
 *
 *          懒汉式:可能出现问题的单例模式
 *                   1)自定义一个类(具体类)
 *                   2)成员位置:声明类型的变量
 *                   3)构造方法私有化
 *                   4)提供对外的公共访问方法:
 *                          需要判断:当前如果没有对象,new 对象
 *
 *                          存在懒加载或者延迟加载!
 *                          可能出现多线程 安全问题:
 *
 *                         如何解决
 *                              加同步锁

public class Tests {

    public static void main(String[] args) {
        /*Student s  =new Student() ;
        Student s2 = new Student() ;
        System.out.println(s==s2) ;//false
        System.out.println(s.getClass()==s2.getClass());//true*/
        //getClass()---->class 包名.类名

       // Student.s = null ; //被外界更改掉

        Student s1 = Student.getStudent();
        Student s2 = Student.getStudent();
        System.out.println(s1==s2);

        System.out.println("-----------------");
        Programmer p1 = Programmer.getPro();
        Programmer p2 = Programmer.getPro();
        Programmer p3 = Programmer.getPro();

        System.out.println(p1==p2);
        System.out.println(p1==p3);

    }
}

 * 标准单例模式之饿汉式:Runtime
 * 个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接
 */
public class RuntTimeDemo {

    public static void main(String[] args) throws IOException {

        Runtime runtime = Runtime.getRuntime();
      //  Runtime runtime2 = Runtime.getRuntime();
        //System.out.println(runtime==runtime2);
        int cpuSize = runtime.availableProcessors();
        System.out.println(cpuSize);
        runtime.exec("notepad") ;
        runtime.exec("mspaint") ;
        runtime.exec("calc") ;
    }
}
public class Student {

    //创建该类实例---(类的实例变量)
//    public static Student s = new Student() ;
    private static Student s = new Student() ;
    private Student(){} //外界不能创建对象

    //提供对外的公共访问方法:静态的
    public static Student getStudent(){
        return s ;
    }
}

public class Programmer {

    private static Programmer pro = null ;

    private Programmer(){}


    //p1,p2,p3
    //对外公共访问方法
    /*public static Programmer getPro(){
        synchronized (Programmer.class){
            if(pro ==null){
                pro = new Programmer() ;
            }
            return pro ;
        }

    }*/
    public synchronized static Programmer getPro(){//静态同步方法:锁对象:当前类名.class属性
            if(pro ==null){
                pro = new Programmer() ;
            }
            return pro ;

    }


}

龟兔赛跑
 *
 *
 * 跑道---作为资源类

public class Race  implements Runnable{

    //当类一加载的时候,定义静态变量
    //胜利者
    private  static String winner = null ;

    //兔子和乌龟都要执行这个run
    @Override
    public void run() {

        //for循环:表示步数1-100步
        for(int x = 1 ; x <= 100 ; x ++){

            //真实故事中:兔子要睡觉的,模拟兔子睡觉
            if(Thread.currentThread().getName().equals("兔子") && (x % 10 ==0 )){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //定义一个定义比赛结束的方法
            boolean flag = gameOver(x) ;
            if(flag){
                break ;
            }
            System.out.println(Thread.currentThread().getName()+"跑了====>"+x+"步");

        }

    }

    //比赛结束的方法
    private boolean gameOver(int step) {//步数  x
        //情况1:如果当前winner不等于null,存在胜利者,比赛结束
        if(winner!=null){
            return true ;
        }{
           //情况2: 判断如果当前step>=100 比赛也要结束
            if(step>=100){
                winner = Thread.currentThread().getName() ;
                System.out.println("winner is:"+winner);
                return true ;
            }
        }
        return false ;
    }


    //用户线程
    public static void main(String[] args) {

        //创建一个资源共享类
        Race race = new Race() ;
        //创建线程类对象
        Thread t1 = new Thread(race,"兔子") ;
        Thread t2 = new Thread(race,"乌龟") ;


        t1.start();
        t2.start();

    }
}

线程组 ThreadGroup 线程组表示一个线程的集合
 *
 * Thread类中方法:
 * public final ThreadGroup getThreadGroup():获取当前所有线程的默认线程组
 * ThreadGroup
 *         public final String getName() :获取默认的线程组名称: (默认就是main)
 *
 *
 *     构造方法:
 *         ThreadGroup(String name):构造一个新的名称的线程组
 *
 *         所有的线程默认的线程组就是main线程(用户线程)

public class ThreadGroupDemo {
    public static void main(String[] args) {
        //method() ;
        method2() ;
    }

    //设置线程组名称
    private static void method2() {
//        ThreadGroup(String name):构造一个新的名称的线程组
          ThreadGroup tg = new ThreadGroup("myMain") ;
          //创建线程类对象:可以将线程组对象作为参数传递
        //public Thread(ThreadGroup group,String name)
        Thread t1 = new Thread(tg,"线程1") ;
        Thread t2 = new Thread(tg,"线程2") ;


        System.out.println(t1.getThreadGroup().getName());
        System.out.println(t2.getThreadGroup().getName());


    }

    private static void method() {
        //创建两个线程类对象

        MyThread my1 = new MyThread() ;
        MyThread my2 = new MyThread() ;

        //获取对应的线程组名称
        ThreadGroup tg1 = my1.getThreadGroup();
        String name = tg1.getName();
        ThreadGroup tg2 = my2.getThreadGroup();
        String name2 = tg2.getName();
        System.out.println(name);
        System.out.println(name2);
    }
}

线程池的使用:
 *  1)接口:ExecutorService :跟踪一个或者多个异步任务
 *  2)如何实例化---->Executors.newFixedThreadPool(int) 工厂方法：
 *
 *  Executors:工厂类
 *              提供创建线程池对象的方法
 *              public static ExecutorService newFixedThreadPool(int nThreads)
 *
 *  ExecutorService
 *          方法:
 *                  Future<?> submit(Runnable task) :通过线程池提交异步任务
 *                  <T> Future<T> submit(Callable<T> task):提交异步任务
 *
 *                  Future:异步任务计算的结果!
 *
 *
 * 第三种方式:线程池实现---->还是自定义一个类 实现Runnable接口

public class ThreadDemo {
    public static void main(String[] args) {


       /* new Thread(){
            @Override
            public void run() {

            }
        }.start();*/
        //创建一个线程池:静态工厂模式
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //提交异步任务
        // Future<?> submit(Runnable task) :通过线程池提交异步任务
       /* pool.submit(new MyRunnable()) ;
        pool.submit(new MyRunnable()) ;*/
       //Callable要比Runnable接口更好
        //可以跟踪具体的异常错误(如果执行过程中,线程出现异常,可以跟踪异常信息!)
       pool.submit(new MyCallable()) ;
       pool.submit(new MyCallable()) ;

        //使用完毕,关闭线程池--将底层产生的线程归还线程池中
        pool.shutdown();

    }
}

j ava.util.Timer:定时器  :有线程安排执行务执行一次，或者定期重复执行。
 *      构造方法:
 *              public Timer() 无参构造方法
 *
 *      成员方法
*              public void cancel():取消定时器
*              public void schedule(TimerTask task,Date time) :在指定日期时间内执行这个任务
*              public void schedule(TimerTask task,long delay):在指定的延迟时间后执行task任务(时间:毫秒)
 *
 *            public void schedule(TimerTask task,
 *                      long delay,
 *                      long period) :在指定的delay延迟时间后开始重复时间间隔period来执行task任务
 *
 *   需求:
 *          在某天的18点将 d://demo文件夹  中的所有的带后缀为.java文件删除掉!  (Timer+io流+递归:综合使用)
 *
 *
 *
 * Java设计原则:
 *      单一职责
 *      接口分离
 *      开闭原则
 *      依赖注入原则(依赖于抽象类或者接口,而不依赖具体类实现)

public class TimerDemo {

    public static void main(String[] args) {
        //创建一个定时器
        Timer timer  = new Timer() ;
        //   public void cancel():取消定时器

        //参数1:定时任务:抽象类,定义子类继承自TimerTask
       // timer.schedule(new MyTask(timer),3000); :3秒后执行一次这个任务

      /*  public void schedule(TimerTask task,
                     long delay,
                       long period) :在指定的delay延迟时间后开始重复时间间隔period来执行task任务*/

      timer.schedule(new MyTask(timer),2000,3000);
    }
}

//定时任务
class MyTask extends TimerTask{ //TimerTask实现Runnable接口         ---会使用同步机制
    private Timer t ;
    public MyTask(Timer t){
        this.t = t ;
    }

    @Override
    public void run() {

        System.out.println("bom...");
        //关闭定时器
        //t.cancel() ;

    }
}

1.多线程创建方式有几种,列举
            
    1)继承自Thread类 重写run方法,然后创建当前类对象 启动线程
    2)实现Runnable接口 重写run方法,然后将当前资源类作为参数传递 到Thread类中 然后启动线程
    
                new Thread(new Runnable(){
                        public void run(){
                            ...
                        }
                
                }).start ;
    3)线程池
          工厂类:Executors 
                        public static ExecutorService newFixedThreadPool(int nThreads)
                        
                                    通过它的子实现对象:ThreadPoolExecutor
                                            7个参数:
                                            
                                            corePoolSize
                                            maxmiumPoolSize
                                            handler:自动启用拒绝策略
                                            TimeUnit:计时器
                                            ThreadFactory---创建新的线程对象
                                                    DefaultThreadFactory
                                            keepAliveTime:保存存活时间
                                            BlockingQueue queue  阻塞队列(Collection)
                ExecutorService
                        Future submit(Callable<E> call) :提交异步任务                        
2.什么是单例模式,请列举两种情况
     创建对象时候,始终保证内存只有一个对象!
     单例模式:
        饿汉式:不会出现安全的单例模式 :Runtime
            当前类一加载的时候,就立即创建一个对象(只有这一个对象)
            1)当前类是一个具体类
            2)类的成员位置:创建的当前静态实例变量并且私有化 
            3)无参构造方法私有化
            4)提供对外的公共访问方法:静态方法,并且返回值是当前类本身
            
            
            public class Student{
                private static Student s = new Student() ;
                
                private Student(){}
                
                public static Student getStudent(){
                    return s ; 
                }
            }
            
        懒汉式:可能出现安全问题的单例模式  (实际开发中:懒加载  / 延迟加载!)
            1)当前类是一个具体类
            2)不会立即创建一个当前类对象:而是声明当类型的成员变量 
            3)无参构造方法私有化
            4)提供对外的静态的公共访问方法:返回值也是当前类本身
                        先判断当前是否存在类对象,如果为null,新创建一个对象
                        返回当前类对象;
                        
            class Teacher{
                private static Teacher t = null ;
                private Teacher(){}
                
                
                //t对象被共用
                //并发的线程 访问公共变量:就会出现冲突
                
                //使用同步机制:synchronized
                public synchronized static Teacher getTeacher(){
                    if(t==null){ //需要使用的时候,才创建对象!
                        t = new Teacher() ; //新建一个对象
                    }
                    
                    return t ;
                }
                
            }        
                    
                    
                    Teacher t1 = Teacher.getTeacher() ;
                    Teacher t2 = Teacher.getTeacher() ;
        

3.什么是简单工厂以及工厂方法模式
            简单工厂:静态工厂方法模式
            优点:不需要具体类 new 具体类,而是需要通过工厂类 
            工厂类的职责:就是负责具体类的对象的创建!
            弊端:
                    当有新的类型增加,需要频繁的修改工厂类代码! (可以使用多态!)
                    
            工厂方法:
                需要有工厂接口,工厂接口中的方法 返回值某个抽象类型
                抽象类还需要有具体的子类,而具体类对象的创建工作:由工厂接口的 的子实现类(具体类的工厂类)
                    
                    interface Factory{
                        public abstract Animal  createAnimal() ;
                    }
                    
                    //狗的工厂类
                    class DogFactory implements Factory(){
                        public Animal createAnimal(){
                            return new Dog() ;
                        }
                    }
                    
                    
                    
                优点:面向接口编程而且使用接口多态,提供功能扩展性
                弊端:代码量大:一个新的类型增加,需要提供工厂类
                    
                    
            

4.集合和数组的区别

    长度区别
            集合:可变
            数组:固定
    存储元素
            集合:可以存储任意类型的元素 :引用类型
            数组:既可以存储引用类型,也可以存储基本类型 (元素类型必须统一)
    
    存储的数据类型区别
            数组:数据类型:必须统一 
            集合:只能引用类型

5.多线程的同步机制是什么
            
            解决:        
                    并发线程中针对公共变量访问冲突变量
                    
                同步机制:四种
                    1)ThreadLocal ----->  数据库连接池会使用! (创建Connection:连接对象)
                    2)同步代码块/同步方法 synchronized
                    3)wait()或者 notify()
                    4)volatile

MES系统

URL是URI的子集

URI
        /dianshang/login
        URI指定的具体的访问的路径:
        协议
            ftp协议
            迅雷协议
            邮件协议
            jdbc:
            http协议

URL:
        网络协议: http/ https:加密协议 更安全
        http://www.baidu.com:80/index.html
        
        http://localhost:8080/dianshang/login

 

 *

Pershings
关注
设计模式4--工厂模式 (Executors 线程池用到）
多多
05-10 2586
工厂模式 主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。    工厂方法模式： 一个抽象产品类，可以派生出多个具体产品类。    一个抽象工厂类，可以派生出多个具体工厂类。      每个具体工厂类只能创建一个具体产品类的实例。     抽象工厂模式： 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。    一个抽象工厂类，可...
并发线程
m0_56413640的博客
04-01 1138
基础类型 java基础 ##集合 ###list集合 ArrayList，LinkedList，（线程安全list）CopyOnWriteArrayList 、ventor ArrayList，LinkedList是线程不安全的，以及CopyOnWriteArrayList和vector为什么安全 线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问保护，有可能
工厂模式创建线程
西木空间
11-25 295
工厂模式创建线程准备工作实现过程工作原理更多关注 工厂模式是面向对象编程中最重要的设计模式之一。这个创造性的模式宗旨是改进对象，使其能够实例化其他类的对象。如果要创建一个类对象，只需要使用工厂模式而无需新的实体对象。 应用工厂模式，进行对象实例化有如下优点： 可以简单的改变对象实例化的类或者对象实例化的方式。 可以为有限的资源简单的限制对象的创建。例如，给定一个类型，限定其只有n个对象。 可以简...
工厂模式（Factory）
weixin_34163553的博客
05-06 140
先来明确一个问题，那就是有的时候，实例化这个活动不应该总是公开的进行， 也就是不要公开的使用 new 操作符，因为，这样容易造成耦合问题。 我们不应该针对实现编程，但是当我们在使用 new 的时候，便是针对实现编程， 而如果您要实例化的话，必须要使用 new 这个关键字， 很明显，这是一个矛盾问题！！！ 当然这里的矛盾并不是说不能够使用 new ，而是更好的使用了 new。 那么如何来...
线程池(工厂模式)
zsn99205的博客
07-03 913
线程（二）[包含单例模式和工厂模式]
WinnerBear的博客
11-25 349
线程
【狂神说笔记——23种设计模式】
weixin_46055348的博客
06-28 1220
【狂神说笔记——23种设计模式】
Java 高并发编程详解：多线程与架构设计
GitChat
12-10 6893
内容简介 本书主要包含四个部分： 部分主要阐述 Thread 的基础知识，详细介绍线程的 API 使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。 第二部分引入了 ClassLoader，这是因为 ClassLoader 与线程不无关系，我们可以通过 synchronized 关键字，或者 Lock 等显式锁的方式在代码的编写阶段对共享资源进行数据一致...
he-Seven-Second-2
03-13
5. **设计模式**：单例、工厂、观察者、装饰者等常见设计模式，用于编写可维护和扩展的代码。 6. **JVM**：Java虚拟机的工作原理，包括内存管理、类加载机制、性能调优等。 7. **Spring框架**：如果项目中使用了...
设计模式笔记
weixin_51558708的博客
09-10 1521
设计模式笔记创建型设计模式`简单工厂模式`定义角色**简单工厂模式在框架源码中的应用****简单工厂模式的优点****简单工厂模式的缺点**`工厂方法模式`介绍角色**使用工厂方法模式实现产品拓展****在`Logback`源码中的应用****缺点**`抽象工厂模式`**介绍****概念**`单例模式`**定义****应用场景****实现方式****使用单例模式解决实际问题**饿汉式 单例写法的弊端懒汉式写法`原型模式`定义应用场景角色使用原型模式解决实际问题存在的问题问题1解决方法问题2解决方法原型模式的
Seahe工厂设计模式源码 1.0.zip
05-25
这是一款简单的工厂设计模式源码，比较适合新手交流使用，具体功能欢迎大家下载研究一下。注意事项1、开发环境为vs2013，无数据库。2、该源码仅供学习交流使用。
【多线程】（五）工厂模式和线程池
最新发布
qq_61635026的博客
07-19 818
线程池是一种管理和复用线程的机制。线程池维护着一个线程队列，其中包含着多个准备好的线程。当有任务需要执行时，线程池中的线程可以被分配来执行任务，执行完成后又可以返回线程池以供下一次使用。
java多线程之流水线工厂模式
woai3364的博客
02-09 539
在主函数里我们创建一个队列来储存任务，并将任务传到每一个线程里来完成加工操作，然后调用start方法开起线程，再调用join方法等待所有线程都完成之后将每个成品打印出来。当第一个产品到第一个工作间用时1个单位时间，再接着进入第二个工作间依次下去，就当第一个产品完成第一个工作间任务时，第二个进入一个工作间。当我们需要对一个产品进行多次不同的操作时，比如我们要对一个队列List 进行加工，先将List传入T1工作间，加工完后，再传入T2、T3进行加工，最后得到成品。这时我们就用到流水线工厂模式进行加工。
c++工厂模式和多线程结合
dejz8829的专栏
05-17 204
void a::create() { Function *f1 = m_functionmanager.CreateFunction(1);Function *f2 = m_functionmanager.CreateFunction(2); vec.push_back(f1); vec.push_back(f2); } void a::createthread() { ...
【源码分析设计模式 3】JDK中的工厂模式，java多线程实战项目
m0_54852680的博客
12-19 760
1、优点 （1）良好的封装性、代码结构清晰。 如一个调用者想创建一个对象，只需要知道其名称即可，降低了模板间的耦合。 （2）扩展性好。 如果想增加一个产品，只需扩展一个工厂类即可。 （3）屏蔽产品类 调用者只关心产品的接口。 （4）典型的解耦框架 2、缺点 每增加一个产品，就需要增加一个产品工厂的类，增加了系统的复杂度。 三、工厂方法模式的应用 1、何时使用 不同条件下创建不用实例时。方法是让子类实现工厂接口。 2、使用场景 （1）需要生成对象的地方。 （2）需要灵活的、可扩展的框架。 （3）数据库访问.
Java多线程 解决private对象逸出-工厂模式(解决对象还未初始化完成就对外暴露)
Java持续实践
09-02 328
文章目录工厂模式 工厂模式 使用工厂模式 ,对象一旦发布就是一个完整的对象, 修复之前如下的文章中, 使用监听器,对象未完成初始化就把对象提供给外界 https://javaweixin6.blog.csdn.net/article/details/108350767 构造方法使用private , 这样其他的对象不能调用构造方法. 创建此工厂方法, 完成了初始化之后, 再进行注册 main方法修改如下 : 完整的代码如下: package com.thread.background; /** *
Java多线程-57-工厂方法设计模式
Anthony_tester的博客
01-08 988
这篇，我们来介绍工厂方法模式。工厂方法模式和前面的简单工厂模式区别就是，我们先定义一个Factory的接口，里面写一个createAnimal的方法。然后Dog就创建DogFactory工厂类，Cat就创建CatFactory工厂类。如果还有其他动物，就创建其他动物的工厂类。这样我们就不用去修改原始的Factory工厂类。这个应用，其实我们在做Selenium POM的时候用到了这种设计模式。 ...
Java多线程-56-简单工厂设计模式
Anthony_tester的博客
01-08 761
关于设计模式，前面我们学习了单例设计模式，这篇再来学习一个工厂方法模式，在介绍工厂方法模式之前，我们来看一个简单工厂模式。工厂模式的最大优点就是客户端不需要再创建对象，工厂类中就帮你提前创建好了，直接通过工厂类名点方法调用就好。简单工厂模式又叫静态方法工厂模式，它定义了一个具体的工厂类来创建一些类的实例。 1.代码举例 在Eclipse下创建一个samplefactory包，然后下面创建以下几...
Java——多线程基本使用（四） 线程组和线程池的使用，工厂设计模式的使用
没有标题
10-12 461
1.线程组的概述和使用 Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。              (1)默认情况下，所有线程都属于线程组                     public final ThreadGroup getThreadGroup() //通过线程对象获取它所属于的组             ...
Java多线程实现线程安全单例模式解析
"本文主要探讨了Java多线程环境下的线程安全单例模式，包括其概念、特点以及两种常见的实现方式：懒汉式和饿汉式。" 在Java编程中，单例模式是一种常用的设计模式，其核心目标是确保一个类在整个应用程序中只有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值