沉睡羊sleepysheep
沉睡羊sleepysheep

多线程的安全与应用

目录

 1.1进程与线程之间的区别与联系

 2-1 通过继承Thread类创建线程

2-2 选择练习 

 2-5 run方法和start方法的区别

​2-6 实现runnable方法接口创建线程

 2-7 选择练习

2-8 自由编程

 2-9 实现Callable接口创建线程

 2-10 线程的生命周期

 2-11 选择练习

3-1 初试线程同步并使用Synchronized实现线程同步

3-2 选择练习 

 3-3 Synchronized在不同场景下锁对象的区别

 3-4 选择练习

3-5 实现线程安全解决超卖现象

4-1 初识线程池及其基本应用

 4-2 线程池的四种类型

4-3 课程总结 

说明：本章的目的是弄明白在java中多线程程序开发有什么细节以及处理过程中有什么需要注意的地方。

 本章主要分为五个部分进行讲解

多线程的安全与应用_第1张图片

 1.1进程与线程之间的区别与联系

多线程的安全与应用_第2张图片

说明：程序就是一个静态的概念

当程序启动以后就会以进程的方式在操作系统的内存中进行驻留

多线程的安全与应用_第3张图片

说明：进程就是程序运行后在内存中的一个实例，进程的一个特性就是彼此之间相互隔离。

根据程序设计的需要有的程序是允许启动多个进程的。

每一个启动的进程在内存中都是独立存储和管理的。

两个记事本的进程彼此互不干扰，有的只允许启动一份，防止出现混乱。

 多线程的安全与应用_第4张图片

说明：进程的资源往往指的是内存文件这些东西，例如当迅雷运行时系统会为其分配128m的内存进行使用，其他的进程就不能对这128m内存进行读取或者写入的操作。这就是资源的隔离性。

 多线程的安全与应用_第5张图片

说明： 线程是进程内部一个一个要执行的任务，例如迅雷下载就是底层创建了3个线程，每一个线程都有一个任务去下载独自的文件，而且这些线程是可以并行执行的，为什么可以并行执行？我们稍后再说

多线程的安全与应用_第6张图片

 说明：如图所示

多线程的安全与应用_第7张图片

说明：因为cpu全局只有一个不可能对所有的线程进行同时执行，为了让我们看起来在同时执行，在操作系统层面上会有一个时间片的概念，时间片也就是cpu的一段执行时间，时间片送给那个线程，那个县城就有当前计算和执行的权力，其他的线程则处于等待状态，直到时间片被分配给其他线程才会执行。

因为时间片是以纳秒级别来分配，所以在感官上我们会觉得所有线程都是在同时运行的，这种情况我们叫做并发执行。

多线程的安全与应用_第8张图片

说明： 随之技术的发展，现在主流的民用cpu都是i5,i7四核八核十六核，这种多核心的情况下就是真正意义上的并行执行了。

不同的线程之间可以拥有不同的cpu分配的时间片，在物理层面上做到了真正的并行执行。

多线程的安全与应用_第9张图片

在java中进程线程是什么关系呢？

像这种只有一个main方法的代码，我们会将它称为java的“单线程”程序

 当程序启动以后会产生一个如图所示的进程，在这个进程中会包含java中所产生的的线程

多线程的安全与应用_第10张图片

 每一个java程序启动后会至少包含两个线程，除了main在java中我们支持垃圾自动回收，可以自动对垃圾对象进行回收，这个就交给了垃圾收集线程执行，对垃圾进行整理标记和收集。

垃圾收集程序因为是每一个java程序都自带的所以我们并不把他算在其中，通常我们提到的java多线程程序就是指通过咱们自己程序代码所创建出来的线程进行的计算和处理，这被称为多线程，这样的程序被称为多线程程序，只有main方法的主线程程序称为单线程程序。

 2-1 通过继承Thread类创建线程

 说明：本节开始进入实战的环节来了解在java语言环境下，如何创建多线程程序，以及如何实现多个任务同时处理

 说明：分别针对以上三种方式来进行讲解

多线程的安全与应用_第11张图片

 说明：为了方便理解我们模拟一个程序，创建一个主线程和额外的三个线程，让三位参赛者同时向前奔跑，最后得到每位参赛者在10秒内跑了多少距离，要怎么做呢？

 创建演示类

多线程的安全与应用_第12张图片

说明： 通过此案例来演示到底为什么需要多线程程序？以及如果我们直接写main方法他是怎么实现的？单线程和多线程的区别？

package com.imooc.thread;

import java.util.Random;
//继承Thread实现多线程程序
public class ThreadSample1 {
    class Runner extends Thread{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + i + "秒：" + this.getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    public void start(){
        Runner threadA = new Runner();
        threadA.setName("参赛者A");
        Runner threadB = new Runner();
        threadB.setName("参赛者B");
        Runner threadC = new Runner();
        threadC.setName("参赛者C");
        Runner threadD = new Runner();
        threadD.setName("参赛者D");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
    }

    public static void main(String[] args) {
        //System.out.println("参赛者A 10秒跑了100米");
        //System.out.println("参赛者B 10秒跑了60米");
        //System.out.println("参赛者C 10秒跑了80米");
        new ThreadSample1().start();
    }
}

本节代码实例

 多线程的安全与应用_第13张图片

 说明：我们的需求是参赛者同时跑，在main方法中显然是无法做到的，main方法作为主方法，前面的方法执行不完后面的语句就一直处于等待的状态。尽管是主线程带无法做到并行执行的效果。

 thread类来实行多线程程序

 class Runner extends Thread{
        @Override
        //新增内部类Runner重写父类方法run()
        public void run() {
            //书写模拟奔跑的程序，随机生成每秒奔跑的速度
            Integer speed = new Random().nextInt(10);
            //模拟10秒钟奔跑的距离
            for(int i = 1 ; i <= 10 ; i++){
                //getName()就是线程的名字
                System.out.println("第" + i + "秒：" + this.getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    //模拟开始奔跑的方法
    public void start(){
        
        Runner threadA = new Runner();
        threadA.setName("参赛者A");

        //新线程的创建和运行
        threadA.start();

    }
    public static void main(String[] args) {
        new ThreadSample1().start();
    }

运行效果：

 多线程的安全与应用_第14张图片

模拟10秒钟跑的距离

 添加方法让线程沉睡1秒钟

多线程的安全与应用_第15张图片

 因为只有一个自定义线程，所以无法体现出同时跑，设置其他参赛者bcd


    public void start(){
        Runner threadA = new Runner();
        threadA.setName("参赛者A");
        Runner threadB = new Runner();
        threadB.setName("参赛者B");
        Runner threadC = new Runner();
        threadC.setName("参赛者C");
        Runner threadD = new Runner();
        threadD.setName("参赛者D");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
    }

 可以看到每一秒abc都是在同时输出信息

多线程的安全与应用_第16张图片

 每增加一个，就增加一个同时跑的人

 每一秒的执行顺序并不相同，这是因为4个线程都会被操作系统分配时间片来进行执行，谁被先分配了时间片就由先执行的权力，cpu的调度各不相同。

2-2 选择练习 

 多线程的安全与应用_第17张图片

 ​​ 

 

 多线程的安全与应用_第18张图片

 

 2-5 run方法和start方法的区别

 多线程的安全与应用_第19张图片

 多线程的安全与应用_第20张图片

 分别调用start()方法和run()方法进行测试

多线程的安全与应用_第21张图片 

多线程的安全与应用_第22张图片2-6 实现runnable方法接口创建线程

 

 java是只支持单继承的,作为java更推崇的方式是实现接口的方式来进行处理

 新建java类

多线程的安全与应用_第23张图片

package com.imooc.thread;

import java.util.Random;
//实现Runnable接口实现多线程程序
public class ThreadSample2 {
    class Runner implements Runnable{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + i + "秒：" + Thread.currentThread().getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    public void start(){
        Runner runner = new Runner();
        Thread threadA = new Thread(runner);
        threadA.setName("参赛者A");
        Thread threadB = new Thread(new Runner());
        threadB.setName("参赛者B");
        Thread threadC = new Thread(new Runner());
        threadC.setName("参赛者C");

        threadA.start();
        threadB.start();
        threadC.start();
    }

    public static void main(String[] args) {
        new ThreadSample2().start();
    }
}

 本节代码示例

    class Runner implements Runnable{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //Thread线程类.currentThread()静态方法，获取到当前执行的线程.getName()得到当前线程名称
                System.out.println("第" + i + "秒：" + Thread.currentThread().getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }
public void start(){
        //实例化Runner对象
        Runner runner = new Runner();
        //实例化Thread类
        Thread threadA = new Thread(runner);
        //设置名称
        threadA.setName("参赛者A");
        Thread threadB = new Thread(new Runner());
        threadB.setName("参赛者B");
        Thread threadC = new Thread(new Runner());
        threadC.setName("参赛者C");
        //启动线程，然后去执行里面的run方法
        threadA.start();
        threadB.start();
        threadC.start();
    }
    //测试
    public static void main(String[] args) {
        new ThreadSample2().start();
    }
}

多线程的安全与应用_第24张图片

 传入实现类，当线程运行时就会去Run方法里规定的业务代码

执行效果

多线程的安全与应用_第25张图片 多线程的安全与应用_第26张图片

 谁获取时间片早就相对靠前

作为实现接口的方式在java中是友好的，所以在日常开发中十分常见。推荐此开发方式

 2-7 选择练习

 多线程的安全与应用_第27张图片

多线程的安全与应用_第28张图片

 

2-8 自由编程

多线程的安全与应用_第29张图片

package com.imooc.thread;

public class ThreadExercise {
    class Cat implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= 3; i++) {
                System.out.println(Thread.currentThread().getName()+"A Cat");
            }
        }
    }
    class Dog implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= 3; i++) {
                System.out.println(Thread.currentThread().getName()+"A Dog");
            }
        }
    }
    public void start(){
        for (int i = 1; i <= 3; i++) {
            System.out.println("main thread");
        }
        //实例化Runner对象
        Dog dog = new Dog();
        Cat cat = new Cat();
        //实例化Thread类
        Thread threadDog = new Thread(dog);
        Thread threadCat = new Thread(cat);
        threadDog.start();
        threadCat.start();
    }

    public static void main(String[] args) {
        ThreadExercise threadExercise = new ThreadExercise();
        threadExercise.start();
        
    }
}

 2-9 实现Callable接口创建线程

 创建类Threadsample3

package com.imooc.thread;

import java.util.Random;
import java.util.concurrent.*;
//实现Callable接口实现多线程程序
public class ThreadSample3 {
    class Runner implements Callable{
        public String name;
        @Override
        public Integer call() throws Exception {
            Integer speed = new Random().nextInt(10);
            Integer result = 0;
            for(int i = 1 ; i <= 10 ; i++){
                Thread.sleep(1000);
                result = i * speed;
                System.out.println("第" + i + "秒：" + this.name + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
            return result;
        }
    }

    public void start() throws ExecutionException, InterruptedException {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Runner threadA = new Runner();
        threadA.name = "参赛者A";
        Runner threadB = new Runner();
        threadB.name = "参赛者B";
        Runner threadC = new Runner();
        threadC.name = "参赛者C";
        //利用Future对象获取每一个线程执行后的结果
        Future r1 = executorService.submit(threadA);
        Future r2 = executorService.submit(threadB);
        Future r3 = executorService.submit(threadC);
        //关闭线程池
        executorService.shutdown();
        System.out.println(threadA.name + "累计跑了" + r1.get() + "米");
        System.out.println(threadB.name + "累计跑了" + r2.get() + "米");
        System.out.println(threadC.name + "累计跑了" + r3.get() + "米");
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new ThreadSample3().start();
    }
}
本节代码示例 

//为什么要定义泛型？原因是利用Callable接口我们实现的应用程序，每一个线程在执行完以后是允许拥有返回值的
    class Runner implements Callable{
        //定义共有成员变量name
        public String name;
        //实现call方法，返回值是Integer
        @Override
        public Integer call() throws Exception {
            //获取随机速度
            Integer speed = new Random().nextInt(10);
            //result是总共要跑的距离，未来要作为执行结果进行返回，默认值为0
            Integer result = 0;
            for(int i = 1 ; i <= 10 ; i++){
                Thread.sleep(1000);
                result = i * speed;
                //name指向的是当前Runner对象的name，而不是线程的名字
                System.out.println("第" + i + "秒：" + this.name + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
            //返回
            return result;
        }
    }

 如何创建多线程程序？

    public void start() throws ExecutionException, InterruptedException {
        //创建线程池，newFixedThreadPool采用定长线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Runner threadA = new Runner();
        threadA.name = "参赛者A";
        Runner threadB = new Runner();
        threadB.name = "参赛者B";
        Runner threadC = new Runner();
        threadC.name = "参赛者C";
        //利用Future对象获取每一个线程执行后的结果 submit运行很快相当于同时进行
        //运行结果封装成Future对象
        Future r1 = executorService.submit(threadA);
        Future r2 = executorService.submit(threadB);
        Future r3 = executorService.submit(threadC);
        //关闭线程池，shutdown会等到所有执行结束后关闭线程池
        executorService.shutdown();
        //打印结果 get得到运行后的结果 也就是call方法return返回的数据
        System.out.println(threadA.name + "累计跑了" + r1.get() + "米");
        System.out.println(threadB.name + "累计跑了" + r2.get() + "米");
        System.out.println(threadC.name + "累计跑了" + r3.get() + "米");
    }

 调用查看结果

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new ThreadSample3().start();
    }

 多线程的安全与应用_第30张图片

最后会出现 

 这种方法除了可以实现线程原本要做的事情以外，还允许出现返回值

 2-10 线程的生命周期

 什么是生命周期？一个事物由生到死的整个阶段。

 多线程的安全与应用_第31张图片

new 新建状态

runnable 可运行状态

blocked 阻塞状态

waiting 等待状态

timed_waiting 超时等待状态

terminated 结束状态也叫死亡状态

 针对这六种不同的线程状态是如何变化的呢？

多线程的安全与应用_第32张图片

什么是锁？

控制线程是否执行的一个标志，这里可以这么认为，锁本身是一个对象，在多线程情况下某一个线程得到了这个锁，当前线程就可以进入到可运行状态，同时cpu也会分配时间片让线程继续执行。

由于操作系统底层的任务调度还有其他的底层资源发生了变化，我们失去了锁，当前线程就会进入阻塞状态，cpu的时间片就不会分配给当前线程

 在线程执行的过程中如果我们按照大类来区分的话，其实只有两种状态可以获得时间片和不可以获得时间片的可运行和阻塞状态。

业界中通行的五种线程状态

 多线程的安全与应用_第33张图片

并不只针对java，线程这个概念是任何操作系统来进行任务调度的时候都会存在的

这个图是宏观的针对线程的状态

 2-11 选择练习

多线程的安全与应用_第34张图片

 多线程的安全与应用_第35张图片

3-1 初试线程同步并使用Synchronized实现线程同步

 什么是线程同步？

多线程的安全与应用_第36张图片

 多线程的安全与应用_第37张图片

 多个线程对同一个对象进行访问的时候，我们需要加入这个同步机制或同步锁来保证线程的有序执行

 创建SyncSample类演示

package com.imooc.thread;

public class SyncSample {

    class Printer{
        //锁对象
        Object lock = new Object();
        //synchronized代码块演示，对自定义对象lock上锁
        public void print1(){
            synchronized (lock) {
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        //synchronized方法 - 对this当前对象上锁
        public synchronized void print2(){
            try {
                //this
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //synchronized静态方法 - 该类的字节码对象Printer.class
        /*
        public static synchronized void print3(){
            try {
                //Printer.class
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        */
    }

    class PrintTask implements Runnable{
        public Printer printer;
        @Override
        public void run() {
            printer.print2();
        }
    }

    public void start(){
        Printer printer = new Printer();
        for(int i = 0 ; i < 10 ; i++){
            PrintTask task = new PrintTask();
            task.printer = printer;
            Thread thread = new Thread(task);
            thread.start();
        }
    }

    public static void main(String[] args) {
        SyncSample sample = new SyncSample();
        sample.start();
    }
}

首先验证不加同步锁代码会产生什么样的问题？

class Printer{
        public void print(){
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
 public void start(){
        Printer printer = new Printer();
        printer.print();
    }

 public static void main(String[] args) {
        SyncSample sample = new SyncSample();
        sample.start();
    }

 打印后魑魅魍魉四个字依次输出看起来没有问题

 因为我们此时只有一个对象，如果多线程情况下同时调用printer对象就会出现问题


 //增加新的内部类
 class PrintTask implements Runnable{
       //定义一个类的成员变量
        public Printer printer;
        @Override
        public void run() {
            printer.print();
        }
    }

进行实质的多线程输出

    public void start(){
        Printer printer = new Printer();
        for(int i = 0 ; i < 10 ; i++){
            PrintTask task = new PrintTask();
            task.printer = printer;
            Thread thread = new Thread(task);
            thread.start();
        }
    }

十个线程都是引用了同一个printer对象 ，大概在同一个时点内多个线程会同时对魑来进行输出然后依次输出，这与我们的预期相差非常多。为了解决这个问题我们要引入锁的机制让线程一个一个排队执行。

如何做到前面的线程没有执行完的话，后面所有的线程就一直处于阻塞等待的状态？

   class Printer{
        //锁对象，要有一个对象，那个线程抢到了这个锁那个线程就有执行这个代码的权力
        Object lock = new Object();
        //synchronized代码块演示，对自定义对象lock上锁
        public void print1(){
            //指明是那个锁
            synchronized (lock) {
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

重新运行

多线程的安全与应用_第38张图片

 定义锁对象，那个线程优先获取到锁，就优先执行，执行后锁会被释放，由其他线程进行争抢，直到所有的线程最后完成处理

3-2 选择练习 

多线程的安全与应用_第39张图片

 多线程的安全与应用_第40张图片

 

 3-3 Synchronized在不同场景下锁对象的区别

 学习Synchronize3种不同的使用办法，通过这三种不同的使用办法了解他的锁对象有哪些

 多线程的安全与应用_第41张图片

 Synchronize代码块：

//锁对象
        Object lock = new Object();
        //synchronized代码块演示，对自定义对象lock上锁
        public void print1(){
            synchronized (lock) {
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

最典型的特性就是自己自定义一个对象对其进行加锁和保护

新人很容易犯得的错误

我们在实例化的时候对task和thread各自创建了十个对象 ，但我们把十个对象全都关联到一个printer对象里面，为什么呢？

因为在多线程访问时只有对同一个对象来进行访问时才可以获取到同一个锁对象。

多线程的安全与应用_第42张图片

假如我们 注释掉printer在每一次创建新的任务的时候去实例化一个新的printer对象

多线程的安全与应用_第43张图片

 运行后会发现整个代码失去了原有的控制，我们每执行一次循环，都创建了一个全新的printer对象，这也就意味着在代码块执行的过程中每一个printer对象都内置了一个lock

 每一个线程都拥有一个自己的锁对象，因此无法达到我们想要的效果

我们需要的效果是所有线程都去共享一把锁，所以我们全局引用一个printer对象，只有一把锁所有线程去争取这一把锁。

使用synochronized方法

        //synchronized方法 - 对this当前对象上锁
        public synchronized void print2(){
            try {
                //this
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

写在方法上进行描述，同时也不需要我们手动指明那个对象来进行加锁

运行测试

多线程的安全与应用_第44张图片

说明可以进行有效的线程同步
我们并没有指定特定的锁对象，就实现了锁的同步这里的原理是什么？

 开发过程中有一个内置的关键字叫做this对象，this关键字代表了当前类的对象

我们调用多少次的方法作为synochronized对象都是对this对象进行加锁

可以看做是synochronized块的简化书写

静态方法进行描述

//synchronized静态方法 - 该类的字节码对象Printer.class
        /*
        public static synchronized void print3(){
            try {
                //Printer.class
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        */

 静态方法是属于类不属于对象的，因为我们现在使用的是一个内部类

 内部类是不允许使用static的所以写上以后就会报错

static描述的方法是属于类的而不是属于方法的，在这个过程中他的锁对象什么呢？

static无法使用this，按照java的规则会使用当前类的class类printer.class来作为锁对象

对static来说是使用的字节码对象来进行加锁谁得到字节码对象谁有执行权限

 3-4 选择练习

 多线程的安全与应用_第45张图片

 多线程的安全与应用_第46张图片

多线程的安全与应用_第47张图片

 

3-5 实现线程安全解决超卖现象

 什么是线程安全？

多线程的安全与应用_第48张图片

 代码实例

创建mall子包演示

多线程的安全与应用_第49张图片

//消费者类
class Consumer implements Runnable{
    //所有消费者都来到同一个商城
    public Mall mall;
    @Override
    public void run() {
        //商城为每一名消费者销售商品
        mall.sale();
    }
}

//库存类
public class Stock {
    //当前商品库存剩余3个
    public static int count = 3;
}

//模拟商城销售商品
public class Mall {
    public void sale(){
        if(Stock.count > 0 ){
            try {
                //模拟商城办理销售业务，用时5毫秒
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //销售成功库存减少
            Stock.count--;
            System.out.println("商品销售成功");
        }else{
            System.out.println("商品库存不足，请下次再来吧！");
        }
    }

    public static void main(String[] args) {
        //实例化唯一的商城对象
        Mall mall = new Mall();
        //模拟5名顾客同时涌入商城购买商品
        for(int i = 0 ; i < 100 ; i++){
            Consumer consumer = new Consumer();
            consumer.mall = mall;
            Thread thread = new Thread(consumer);
            thread.start();
        }
        try {
            //模拟下班后判断库存
            Thread.sleep(1000);
            System.out.println("当前商品库存为：" + Stock.count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

只有一名顾客时处理的逻辑

 5名时就变成了

这时就会产生超卖现象 倒赔2台手机

这就是典型的线程安全问题

在单线程处理的时候运行逻辑是正常的，但是一旦到多线程运行的时候就会出现没有预估到的效果，就是线程安全问题

 多线程的安全与应用_第50张图片

 如何解决？

所有的线程安全问题都是多个线程访问一个对象，而我们没有对着一个对象进行有效规划造成的，引入之前学的线程同步解决这个问题 增加synchronized关键字

public class Mall {
    public synchronized void sale(){
        if(Stock.count > 0 ){
            try {
                //模拟商城办理销售业务，用时5毫秒
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //销售成功库存减少
            Stock.count--;
            System.out.println("商品销售成功");
        }else{
            System.out.println("商品库存不足，请下次再来吧！");
        }
    }

运行

多线程的安全与应用_第51张图片

 如何快速打开java自带类的源码？

ctrl+n键

输入类名 

打开ArrayList

多线程的安全与应用_第52张图片

并没有synchronized 关键字进行描述

但是在Vector却使用了synchronized 关键字进行描述

多线程的安全与应用_第53张图片

 加和不加就意味着当前方法是不是线程安全的，加上就是没加就不是

为什么开发时都在使用ArrayList而不再使用早期的Vector呢？

原因是通过ArrayList可以有效通过我们执行的速度，平时工作过程中多线程还是少见的，我们要快速的完成对数据的处理和操作。所以会优先选择线程不安全的方法

4-1 初识线程池及其基本应用

 首先来了解一个包

多线程的安全与应用_第54张图片

 在并发包中最核心的组件就是线程池了

多线程的安全与应用_第55张图片

多线程的安全与应用_第56张图片

 多线程的安全与应用_第57张图片

 4-2 线程池的四种类型

 通过代码介绍四种线程池的不同类型和特点

创建pool包

多线程的安全与应用_第58张图片

 新建第一个案例ThreadPoolSample1 定长线程池

public class ThreadPoolSample1 {
    public static void main(String[] args) {
        //创建一个可创建一个定长线程池，最大只允许在线程池中有10个线程同时运行
        //定长线程池的特点是固定线程总数，空闲线程用于执行任务，如果线程都在使用，后续任务则处于等待状态
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        //验证一下下线程池做法 
        for(int i = 1; i <= 1000 ; i++){
            final int index = i;
            //不需要返回值，使用execute方法执行Runnable对象
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //获取当前线程名字
                    System.out.println(Thread.currentThread().getName()+":" + index );
                }
            });
        }
        //处理完毕关闭线程池
        threadPool.shutdown();
    }
}

运行看是否最多10个线程执行任务

多线程的安全与应用_第59张图片

 可以看到只有10个线程的名字，通过10个固定长度的线程处理了1000个任务

 如果需要返回值呢？

            /*
            需要返回值，使用submit方法执行Callable对象，利用Future对象接收返回值
            Future ret = threadPool.submit(new Callable() {
                @Override
                public Object call() throws Exception {
                    return null;
                }
            });
            */ 
  
增加其他三种类型代码案例
 
  
 
  
public class ThreadPoolSample2 {
    public static void main(String[] args) {
        //调度器对象
        //ExecutorService用于管理线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();//创建一个可缓存线程池
        //可缓存线程池的特点是，无限大，如果线程池中没有可用的线程则创建，有空闲线程则利用起来
        for(int i = 1 ; i <= 1000 ; i++) {
            final  int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
        threadPool.shutdown();
    }
}
 
  
多线程的安全与应用_第60张图片 
 
  
 
   
作为可缓存线程池主要代码和定长线程池几乎一样，唯一不同的是Executors.newCachedThreadPool();//创建一个可缓存线程池，同时并没有传入任何线程的总量
 
  
 
  
public class ThreadPoolSample3 {
    public static void main(String[] args) {
        //调度器对象
        //ExecutorService用于管理线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单线程线程池
        for(int i = 1 ; i <= 1000 ; i++) {
            final  int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
        threadPool.shutdown();
    }
}

 
  
多线程的安全与应用_第61张图片 
 
  
 
   
单线程代表所有的任务都通过一个任务排队来执行
 
   
Executors.newSingleThreadExecutor();//单线程线程池
 
  
 
  
public class ThreadPoolSample4 {
    public static void main(String[] args) {
        //调度线程池
        ScheduledExecutorService scheduledThreadPool =  Executors.newScheduledThreadPool(5);//可调度线程池
        //延迟1秒执行，每三秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(new Date() + "延迟1秒执行，每三秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }
}
 
  
 
 
  
 
   
调度线程池就是定时执行某个任务
 
   
Executors.newScheduledThreadPool(5);//可调度线程池
 所有任务都是以定时的时长间隔来执行run方法中所规定的东西
 
  
 
  
4-3 课程总结 
 
  
 
  
 多线程的安全与应用_第62张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(多线程,java)

        

            

                
    
                    
  • linux线程池的实现-线程的单例模式(懒汉饿汉模式)
                        Chen chen chen

                        
    线程池:一个或多个线程+任务队列;为什么要有线程池:一个程序起来以后立即启动了很多线程然后取处理任务,如果每来一个请求都创建一个线程线程占资源,如果一瞬间来了很多请求会把资源耗尽程序奔溃了应用场景:(1)启动线程处理任务请求,若同一时间因为大量请求创建大量线程有可能导致资源耗尽程序奔溃(需要限制上限)(2)创建线程(t1)+t2(处理任务时间)+t3销毁线程=总花费时间tt1+t3/t线程创建销毁
    
                    
    • 
                    
  • 由于直接提供完整的游戏商城代码超出了简单回答的范围，并且游戏商城的实现可以相当复杂，涉及前端展示、后端逻辑、数据库设计等多个方面，我会分别用几种流行的编程语言和技术栈概述如何开始搭建一个基本的游戏商城
                        编程小飞侠a
游戏前端数据库
                        
    前端（HTML/CSS/JavaScript+React）React示例:fengbaoshun.com首先，你需要安装Node.js和npm（Node包管理器），然后使用CreateReactApp来快速启动你的前端项目。bashnpxcreate-react-appgame-store-frontendcdgame-store-frontendnpmstart接下来，你可以使用React组件来
    
                    
    • 
                    
  • 由于直接提供完整的大型项目代码（如购物商城）在单一回答中是不切实际的，我将为你概述如何在几种流行的编程语言中设置购物商城的基本框架和思路。这包括前端（如HTML/CSS/JavaScript）和后端（
                        SigridFelix
前端htmlcss
                        
    前端（HTML/CSS/JavaScript）dz61.comHTML:创建基础的页面结构，如主页、商品列表页、购物车页和结账页。html我的购物商城欢迎来到我的购物商城商品列表购物车CSS:简单的样式表，用于美化页面。css/*styles.css*/body{font-family:Arial,sans-serif;}h1{color:#333;}ul{list-style-type:none
    
                    
    • 
                    
  • 从零开始构建一个JAVA项目
                        SUGERBOOM
javalog4j开发语言
                        
    本篇文章将从结构框架入手，系统介绍一个完整Java程序的结构步骤，不涉及JAVA基础代码学习。在本文章中先简单介绍Maven、Spring、MyBatis三种Java类型。一、分类介绍首先我们先来了解Java程序的类型，不同类型结构略有区别。Java程序的类型可以根据多个分类方式进行划分，以下是一些常见的分类和简要解释：构建工具类型：Maven：用于管理项目的构建、报告和文档的生成。它提供了一种标
    
                    
    • 
                    
  • 计算机毕业设计ssm基于Web的医院陪诊系统的设计与实现go8299（附源码）新手必备
                        一念 计算机毕设源码程序
课程设计前端
                        
    本项目包含程序+源码+数据库+LW+调试部署环境，文末可获取一份本项目的java源码和数据库参考。系统的选题背景和意义选题背景：随着社会的发展和人们生活水平的提高，医疗服务的需求也越来越多样化。在传统的医院就诊过程中，患者通常需要自行前往医院，并且由于医生工作繁忙，陪诊时间有限，导致患者在就诊过程中感到孤独和不安。而基于Web的医院陪诊系统的设计与实现，可以为患者提供更加便捷和贴心的就医体验。意义
    
                    
    • 
                    
  • Spring Boot 整合 MySQL 和 Druid 连接池
                        疯狂的键盘侠
springbootmysqlspringbootmysqldruid
                        
    SpringBoot整合MySQL和Druid连接池一、引言在JavaWeb开发中，SpringBoot凭借其简洁的配置和强大的功能成为主流框架，而MySQL作为常用的关系型数据库，与SpringBoot的结合十分紧密。Druid是阿里巴巴开源的一款高性能数据库连接池，它提供了丰富的监控和扩展功能，能有效提升应用程序与数据库交互的性能和稳定性。本文将详细介绍如何在SpringBoot2和Sprin
    
                    
    • 
                    
  • 【前沿聚焦】机器学习的未来版图：从自动化到隐私保护的技术突破
                        网罗开发
人工智能AI大模型机器学习人工智能
                        
    网罗开发（小红书、快手、视频号同名）  大家好，我是展菲，目前在上市企业从事人工智能项目研发管理工作，平时热衷于分享各种编程领域的软硬技能知识以及前沿技术，包括iOS、前端、HarmonyOS、Java、Python等方向。在移动端开发、鸿蒙开发、物联网、嵌入式、云原生、开源等领域有深厚造诣。图书作者：《ESP32-C3物联网工程开发实战》图书作者：《SwiftUI入门，进阶与实战》超级个体：CO
    
                    
    • 
                    
  • Spring Boot 高级开发指南：全面掌握微服务架构的关键技术
                        IT古董
JAVA架构springboot微服务
                        
    SpringBoot是现代Java开发的主流框架，尤其在构建微服务架构时，它提供了丰富的工具与功能，帮助开发者快速构建高效、健壮的系统。本文将围绕13个关键的高级概念展开，逐一分析SpringBoot在微服务开发中的核心技术，包括配置与属性管理、Bean生命周期与作用域、国际化、缓存、部署运维、弹性微服务、分布式事务等，配合实际代码与案例，帮助开发者深入理解和应用SpringBoot。1.配置与属
    
                    
    • 
                    
  • 【华为OD-E卷 - 字符串解密 100分（python、java、c++、js、c）】
                        CodeClimb
算法题华为od（A+B+C+D+E卷）收录分享华为odpythonjavac++javascript
                        
    【华为OD-E卷-字符串解密100分（python、java、c++、js、c）】题目给定两个字符串string1和string2。string1是一个被加扰的字符串。string1由小写英文字母（’a’~’z’）和数字字符（’0’~’9’）组成，而加扰字符串由’0’~’9’、’a’~’f’组成。string1里面可能包含0个或多个加扰子串，剩下可能有0个或多个有效子串，这些有效子串被加扰子串隔开
    
                    
    • 
                    
  • 【Java】--方法的使用
                        雨雨雨点子
JavaSEjava开发语言
                        
    文章目录1.方法概念及使用1.1什么是方法1.2方法定义1.3方法调用的执行过程1.4实参和形参的关系（重要）1.5没有返回值的方法2.方法重载2.1方法重载概念2.2方法签名3.递归3.1递归的概念3.2递归执行过程分析3.3递归练习1.方法概念及使用1.1什么是方法方法就是一个代码片段.类似于C语言中的“函数”。方法存在的意义(不要背,重在体会):是能够模块化的组织代码(当代码规模比较复杂的时
    
                    
    • 
                    
  • LeetCode - #195 Swift 实现打印文件中的第十行
                        网罗开发
Swiftvue.jsleetcodeswift
                        
    网罗开发（小红书、快手、视频号同名）  大家好，我是展菲，目前在上市企业从事人工智能项目研发管理工作，平时热衷于分享各种编程领域的软硬技能知识以及前沿技术，包括iOS、前端、HarmonyOS、Java、Python等方向。在移动端开发、鸿蒙开发、物联网、嵌入式、云原生、开源等领域有深厚造诣。图书作者：《ESP32-C3物联网工程开发实战》图书作者：《SwiftUI入门，进阶与实战》超级个体：CO
    
                    
    • 
                    
  • GPT4All:免费使用本地运行无需GPU的基于C++的GPT模型和UI: A free-to-use, locally running, privacy-aware chatbot. No GPU
                        AI天才研究院
ChatGPT大数据AI人工智能LLM大模型落地实战指南gpt人工智能语言模型自然语言处理编程实践开发语言c++
                        
    目录GPT4All:https://github.co:m/nomic-ai/gpt4allGPT4AllChatUIGPT4All聊天用户界面效果测试问题：HowtowriteamultipleThreadcodeInJava?输出：GPT4All如何运作RunningLLMsonCPU在CPU上运行LLMSideloadinganyggMLmodel加载任何ggML模型GPT4ALL:目前已经
    
                    
    • 
                    
  • 【MQ】如何保证消息队列的高性能？
                        Forest 森林
消息队列MQkafka
                        
    零拷贝Kafka使用到了mmap和sendfile的方式来实现零拷贝。分别对应Java的MappedByteBuffer和FileChannel.transferTo顺序写磁盘Kafka采用顺序写文件的方式来提高磁盘写入性能。顺序写文件，基本减少了磁盘寻道和旋转的次数完成一次磁盘IO，需要经过寻道、旋转和数据传输三个步骤，如果在写磁盘的时候省去寻道、旋转可以极大地提高磁盘读写的性能。Kafka中每
    
                    
    • 
                    
  • Junit和Eclemma介绍--java白盒测试工具
                        myy_2018
JAVA
                        
    Junit一般进行单元测试时候使用，以前写好了模块，然后写一个main函数，写几个通用的测试用例去测试代码的逻辑结果是否正确，现在Eclipse中Junit插件使得不必须手动编写main函数，可以借助Junit编写测试函数，自动生成与模块相匹配的测试模块。我们只需要添加测试用例即可，并且结果显示是否与预期符合。Eclemma是Junit配合使用的插件，是测试覆盖率的工具，对于含有条件判断的代码，对
    
                    
    • 
                    
  • 【用Java学习数据结构系列】初识泛型
                        Gu Gu Study
【用Java学习数据结构系列】java数据结构机器学习人工智能
                        
    看到这句话的时候证明：此刻你我都在努力加油陌生人br/>个人主页：GuGuStudy专栏：用Java学习数据结构系列喜欢的一句话：常常会回顾努力的自己，所以要为自己的努力留下足迹喜欢的话可以点个赞谢谢了。作者：小闭前言好久没有更新文章了，大概断更了20天，想着今天就写一下文章吧！最近也是又温习了一下数据结构，其实之前我写过关于数据结构的一个专栏那个专栏是写了顺序表，链表，栈和队列，但是那时是用C语
    
                    
    • 
                    
  • 日志收集Day008
                        ccnnlxc
java开发语言
                        
    1.zk集群优化修改zookeeper的堆内存大小，一般情况下，生产环境给到2G足以，如果规模较大可以适当调大到4G。(1)配置ZK的堆内存vim/app/softwares/zk/conf/java.envexportJAVA_HOME=/sortwares/jdk1.8.0_291exportJVMFLAGS="-Xms256m-Xmx256m$JVMFLAGS"EOF(2)同步文件到其他节点
    
                    
    • 
                    
  • Java实现在线聊天_java实现聊天功能
                        简介_vN
javacocoa开发语言
                        
    资源绑定是指把业务相关的数据和Tcp连接（即ChannelContext）关联起来，譬如ChannelContext-A代表了用户张三，张三的userid是333Tio.bindUser(ChannelContext-A,"333")t-io目前内置了4种资源绑定，譬如给group加前缀"ios-"，从而标记这个用户使用的是iosTio.bindGroup(ChannelContext-A,"33
    
                    
    • 
                    
  • 【前端】--- ES6上篇（带你深入了解ES6语法）
                        心.c
javascriptes6开发语言ecmascripthtmlcss
                        
    前言：ECMAScript是JavaScript的标准化版本，由ECMA国际组织制定。ECMAScript定义了JavaScript的语法、类型、语句、关键字、保留字等。ES6是ECMAScript的第六个版本，于2015年发布，引入了许多重要的新特性，使JavaScript更加现代化。目录变量声明：let声明:var声明:const声明:解构（数组，对象，字符串）：数组解构：对象解构：字符串解构
    
                    
    • 
                    
  • cv python_python里面cv是什么意思
                        weixin_40004659
cvpython
                        
    OpenCV(OpenSourceComputerVisionLibrary)开放源代码计算机视觉库，主要算法涉及图像处理、计算机视觉和机器学习相关方法。OpenCV其实就是一堆C和C++语言的源代码文件，这些源代码文件中实现了许多常用的计算机视觉算法。OpenCV由一系列C函数和C++类构成，它有C，C++，Python和java接口，当前SDK(SoftwareDevelopmentKit软件
    
                    
    • 
                    
  • 【如何获取股票数据05】Python、Java等多种主流语言实例演示获取股票行情api接口之沪深A股最新分时MA数据获取实例演示及接口API说明文档
                        码农蝶澈
pythonjava开发语言股票数据API股票数据接口
                        
    最近一两年内，股票量化分析逐渐成为热门话题。而从事这一领域工作的第一步，就是获取全面且准确的股票数据。因为无论是实时交易数据、历史交易记录、财务数据还是基本面信息，这些数据都是我们进行量化分析时不可或缺的宝贵资源。我们的主要任务是从这些数据中提炼出有价值的信息，为我们的投资策略提供有力的指导。在数据探索的旅途中，我尝试了多种方法，包括自编网易股票页面爬虫、申万行业数据爬虫，以及同花顺问财的爬虫，甚
    
                    
    • 
                    
  • 访问DOM元素（节点）
                        froginwe11
开发语言
                        
    DOM（文档对象模型）是Web开发中用于处理HTML和XML文档的标准接口，它允许开发者通过脚本语言（如JavaScript）动态地访问和修改文档的结构、内容和样式。在DOM中，文档的每个部分都被视为一个节点，包括元素、文本、属性等。访问DOM元素（节点）DOM提供了一系列方法来访问和操作元素（节点）：getElementById()：通过元素的ID获取元素节点。例如，document.getEl
    
                    
    • 
                    
  • Java web 富文本内容生成转为word格式并导出下载
                        摘星喵Pro
javaweb编程技巧java前端servlet
                        
    Javaweb富文本内容生成转为word格式并导出下载最近思路，按标签逐一解析，实现复杂一点但是完美解决问题：https://blog.csdn.net/a2272062968/article/details/126227076思路：Word是完全支持html标签的，但是富文本内容并不是完整的html代码，需要先补全html标签，然后转码输出问题：虽然导出worddoc但是事件内容流还是htm，只
    
                    
    • 
                    
  • Word、PDF转换为图片Java
                        摘星喵Pro
wordpdfjavapoi
                        
    Word、PDF转换为图片Java需求要在小程序端展示文档内容，所以将文档每页转换为图片后显示参考和其他等方案：https://blog.csdn.net/strggle_bin/article/details/140599514https://www.modb.pro/db/566986https://blog.csdn.net/spring_is_coming/article/details/
    
                    
    • 
                    
  • 【如何获取股票数据01】Python、Java等多种主流语言实例演示获取股票行情api接口之沪深A股实时交易数据获取实例演示及接口API说明文档
                        Eumenides_max
pythonjava开发语言
                        
    最近一两年内，股票量化分析逐渐成为热门话题。而从事这一领域工作的第一步，就是获取全面且准确的股票数据。因为无论是实时交易数据、历史交易记录、财务数据还是基本面信息，这些数据都是我们进行量化分析时不可或缺的宝贵资源。我们的主要任务是从这些数据中提炼出有价值的信息，为我们的投资策略提供有力的指导。在数据探索的旅途中，我尝试了多种方法，包括自编网易股票页面爬虫、申万行业数据爬虫，以及同花顺问财的爬虫，甚
    
                    
    • 
                    
  • 股票实时行情数据API接口分享
                        2301_78150700
pythonjava
                        
    JAVA版本API接口分享：importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.net.HttpURLConnection;importjava.net.URL;publicclassTestMain{publicstaticvoidmain(String
    
                    
    • 
                    
  • 股票数据接口API实例代码python、JAVA等多种语言演示免费获取实时数据、历史数据、CDMA、KDJ等指标数据配有API说明文档
                        Eumenides_max
pythonjava开发语言
                        
    本文中所有接口均可直接在浏览器打开获取数据，为了便于大家验证有效性，已经做好了超链接，直接点击即可！沪深两市股票列表API接口链接（可点击验证）：https://api.mairui.club/hslt/list/b997d4403688d5e66a【实时数据接口】沪深两市实时交易数据接口API接口链接（可点击验证）：https://api.mairui.club/hsrl/ssjy/000001
    
                    
    • 
                    
  • Thymeleaf基础知识语法
                        沐暖沐
thymeleaf开发语言
                        
    1、简介Thymeleaf是⾯向Web和独⽴环境的现代服务器端Java模板引擎，能够处理HTML、XML、JavaScript、CSS、TEXT、RAW这六种模板。这六种模版模式包含两种标记模板模式（HTML和XML），三种⽂本模板模式（TEXT，JAVASCRIPT和CSS）和⼀个⽆操作模板模式（RAW）。①简单表达式变量表达式：${…}选择变量表达式：*{…}消息表达：#{…}链接URL表达式
    
                    
    • 
                    
  • 华为机试HJ16：购物单 系统的动态规划设计思路 剖析Java最优解代码
                        _JC_Chris
华为动态规划java算法数据结构
                        
    0.写在前面“华为机试HJ16：购物单”是一道“物品间有依赖关系”的【01背包问题】，属于经典dp问题的变形。对于基础薄弱的同学来说，本题的思维难度不低，建议先了解“普通01背包问题”的基本求解思路——bilibili辅助学习视频（预计学习时间15min）1.题目描述王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：主件附件电脑打印
    
                    
    • 
                    
  • JVM --- 类的生命周期
                        Wangwq.
八股文JVM
                        
    一、类的生命周期加载-----》校验-----》准备-----》解析-----》初始化-----》使用-----》卸载二、类加载过程1、加载（1）主要工作：通过类的全限定名来获取定义此类的二进制字节流。将这个类字节流代表的静态存储结构转换为方法区的运行时数据结构。在堆中生成了一个代表此类的java.lang.Class对象，作为访问这些方法区的数据入口。（2）支持的两种类加载器：引导类加载器用户（
    
                    
    • 
                    
  • @Contended
                        qq_31273845
springjava后端
                        
    `@Contended`是Java8引入的一个注解，主要用于减少多线程环境下的伪共享（FalseSharing）问题。伪共享是由于缓存行的争用导致的性能问题，特别是在多核处理器上。###`@Contended`注解的作用-**减少伪共享**：当多个线程访问不同的变量，但这些变量位于同一个缓存行时，可能会引发伪共享问题。`@Contended`注解通过在变量之间插入填充字段，确保它们位于不同的缓存行
    
                    
    • 
                                
  • VMware Workstation 11 或者 VMware Player 7安装MAC OS X 10.10 Yosemite
                                    iwindyforest
vmwaremac os10.10workstationplayer
                                    
    最近尝试了下VMware下安装MacOS 系统， 
安装过程中发现网上可供参考的文章都是VMware Workstation 10以下， MacOS X 10.9以下的文章， 
只能提供大概的思路， 但是实际安装起来由于版本问题， 走了不少弯路， 所以我尝试写以下总结， 希望能给有兴趣安装OSX的人提供一点帮助。 
  
  
写在前面的话： 
其实安装好后发现， 由于我的th
    
                                
    • 
                                
  • 关于《基于模型驱动的B/S在线开发平台》源代码开源的疑虑？
                                    deathwknight
JavaScriptjava框架
                                    
    本人从学习Java开发到现在已有10年整，从一个要自学 java买成javascript的小菜鸟，成长为只会java和javascript语言的老菜鸟（个人邮箱：[email protected]） 
 
一路走来，跌跌撞撞。用自己的三年多业余时间，瞎搞一个小东西（基于模型驱动的B/S在线开发平台，非MVC框架、非代码生成）。希望与大家一起分享，同时有许些疑虑，希望有人可以交流下 
 
平台
    
                                
    • 
                                
  • 如何把maven项目转成web项目
                                    Kai_Ge
mavenMyEclipse
                                    
    创建Web工程，使用eclipse ee创建maven web工程 1.右键项目,选择Project Facets,点击Convert to faceted from 2.更改Dynamic Web Module的Version为2.5.(3.0为Java7的,Tomcat6不支持). 如果提示错误,可能需要在Java Compiler设置Compiler compl
    
                                
    • 
                                
  • 主管？？？
                                    Array_06
工作
                                    
    转载：http://www.blogjava.net/fastzch/archive/2010/11/25/339054.html 
 
 
 
 
很久以前跟同事参加的培训，同事整理得很详细，必须得转！ 
 
前段时间，公司有组织中高阶主管及其培养干部进行了为期三天的管理训练培训。三天的课程下来，虽然内容较多，因对老师三天来的课程内容深有感触，故借着整理学习心得的机会，将三天来的培训课程做了一个
    
                                
    • 
                                
  • python内置函数大全
                                    2002wmj
python
                                    
    最近一直在看python的document，打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面，其实在看的时候发现整个《The Python Standard Library》章节都是很不错的，其中描述了很多不错的主题。先把Build-in Fu
    
                                
    • 
                                
  • JSP页面通过JQUERY合并行
                                    357029540
JavaScriptjquery
                                    
    在写程序的过程中我们难免会遇到在页面上合并单元行的情况，如图所示 
 
 
如果对于会的同学可能很简单，但是对没有思路的同学来说还是比较麻烦的，提供一下用JQUERY实现的参考代码 
 
function mergeCell(){ 
        var trs = $("#table tr"); 
&nb
    
                                
    • 
                                
  • Java基础
                                    冰天百华
java基础
                                    
    学习函数式编程 
package base;

import java.text.DecimalFormat;

public class Main {

	public static void main(String[] args) {
//		Integer a = 4;  
//		Double aa = (double)a  / 100000;  
//		Decimal
    
                                
    • 
                                
  • unix时间戳相互转换
                                    adminjun
转换unix时间戳
                                    
    如何在不同编程语言中获取现在的Unix时间戳(Unix timestamp)？     Java time   JavaScript Math.round(new Date().getTime()/1000)
getTime()返回数值的单位是毫秒   Microsoft .NET / C# epoch = (DateTime.Now.ToUniversalTime().Ticks - 62135
    
                                
    • 
                                
  • 作为一个合格程序员该做的事
                                    aijuans
程序员
                                    
    作为一个合格程序员每天该做的事   1、总结自己一天任务的完成情况 最好的方式是写工作日志，把自己今天完成了什么事情，遇见了什么问题都记录下来，日后翻看好处多多 
2、考虑自己明天应该做的主要工作 把明天要做的事情列出来，并按照优先级排列，第二天应该把自己效率最高的时间分配给最重要的工作 
3、考虑自己一天工作中失误的地方，并想出避免下一次再犯的方法 出错不要紧，最重
    
                                
    • 
                                
  • 由html5视频播放引发的总结
                                    ayaoxinchao
html5视频video
                                    
    前言 
  
项目中存在视频播放的功能，前期设计是以flash播放器播放视频的。但是现在由于需要兼容苹果的设备，必须采用html5的方式来播放视频。我就出于兴趣对html5播放视频做了简单的了解，不了解不知道，水真是很深。本文所记录的知识一些浅尝辄止的知识，说起来很惭愧。 
  
视频结构 
  
本该直接介绍html5的<video>的，但鉴于本人对视频
    
                                
    • 
                                
  • 解决httpclient访问自签名https报javax.net.ssl.SSLHandshakeException: sun.security.validat
                                    bewithme
httpclient
                                    
         如果你构建了一个https协议的站点，而此站点的安全证书并不是合法的第三方证书颁发机构所签发，那么你用httpclient去访问此站点会报如下错误 
  
javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path bu
    
                                
    • 
                                
  • Jedis连接池的入门级使用
                                    bijian1013
redisredis数据库jedis
                                    
    Jedis连接池操作步骤如下： 
        a.获取Jedis实例需要从JedisPool中获取； 
        b.用完Jedis实例需要返还给JedisPool； 
        c.如果Jedis在使用过程中出错，则也需要还给JedisPool； 
packag
    
                                
    • 
                                
  • 变与不变
                                    bingyingao
不变变亲情永恒
                                    
    变与不变 
   周末骑车转到了五年前租住的小区，曾经最爱吃的西北面馆、江西水饺、手工拉面早已不在， 
   各种店铺都换了好几茬，这些是变的。 
   三年前还很流行的一款手机在今天看起来已经落后的不像样子。 
   三年前还运行的好好的一家公司，今天也已经不复存在。 
   一座座高楼拔地而起，
    
                                
    • 
                                
  • 【Scala十】Scala核心四：集合框架之List
                                    bit1129
scala
                                    
    Spark的RDD作为一个分布式不可变的数据集合，它提供的转换操作，很多是借鉴于Scala的集合框架提供的一些函数，因此，有必要对Scala的集合进行详细的了解 
  
1. 泛型集合都是协变的，对于List而言，如果B是A的子类，那么List[B]也是List[A]的子类，即可以把List[B]的实例赋值给List[A]变量 
  
2. 给变量赋值(注意val关键字，a，b
    
                                
    • 
                                
  • Nested Functions in C
                                    bookjovi
cclosure
                                    
      
Nested Functions 又称closure，属于functional language中的概念，一直以为C中是不支持closure的，现在看来我错了，不过C标准中是不支持的，而GCC支持。 
  
既然GCC支持了closure，那么 lexical scoping自然也支持了，同时在C中label也是可以在nested functions中自由跳转的
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-WeakHashMap
                                    BrokenDreams
Collections
                                    
            总结这个类之前，首先看一下Java引用的相关知识。Java的引用分为四种：强引用、软引用、弱引用和虚引用。 
 
        
强引用：就是常见的代码中的引用，如Object o = new Object();存在强引用的对象不会被垃圾收集
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-解释器模式-Interpret
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 

package design.pattern;

/*
 * 解释器（Interpreter）模式的意图是可以按照自己定义的组合规则集合来组合可执行对象
 * 
 * 代码示例实现XML里面1.读取单个元素的值 2.读取单个属性的值
 * 多
    
                                
    • 
                                
  • After Effects操作&快捷键
                                    cherishLC
After Effects
                                    
    1、快捷键官方文档 
 
 
 中文版：https://helpx.adobe.com/cn/after-effects/using/keyboard-shortcuts-reference.html  
 英文版：https://helpx.adobe.com/after-effects/using/keyboard-shortcuts-reference.html  
 
 
 2、常用快捷键
    
                                
    • 
                                
  • Maven 常用命令
                                    crabdave
maven
                                    
    Maven 常用命令 
  
mvn archetype:generate 
mvn install 
mvn clean 
mvn clean complie 
mvn clean test 
mvn clean install 
mvn clean package 
mvn test 
mvn package 
mvn site 
  
mvn dependency:res
    
                                
    • 
                                
  • shell bad substitution
                                    daizj
shell脚本
                                    
    #!/bin/sh 
 
/data/script/common/run_cmd.exp 192.168.13.168 "impala-shell -islave4 -q 'insert OVERWRITE table imeis.${tableName} select ${selectFields}, ds, fnv_hash(concat(cast(ds as string), im
    
                                
    • 
                                
  • Java SE 第二讲（原生数据类型 Primitive Data Type）
                                    dcj3sjt126com
java
                                    
    Java SE  第二讲： 
 
1.   Windows: notepad, editplus, ultraedit, gvim 
Linux: vi, vim, gedit 
 
2.   Java 中的数据类型分为两大类： 
1）原生数据类型  （Primitive Data Type） 
2）引用类型（对象类型）  （R
    
                                
    • 
                                
  • CGridView中实现批量删除
                                    dcj3sjt126com
PHPyii
                                    
    1，CGridView中的columns添加 
array(
                        'selectableRows' => 2,
                        'footer' => '<button type="button" onclick="GetCheckbox();" style=&
    
                                
    • 
                                
  • Java中泛型的各种使用
                                    dyy_gusi
java泛型
                                    
    Java中的泛型的使用：1.普通的泛型使用 
在使用类的时候后面的<>中的类型就是我们确定的类型。 
public class MyClass1<T> {//此处定义的泛型是T
    private T var;

    public T getVar() {
        return var;
    }

    public void setVa
    
                                
    • 
                                
  • Web开发技术十年发展历程
                                    gcq511120594
Web浏览器数据挖掘
                                    
    回顾web开发技术这十年发展历程： 
Ajax 
03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。 
彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
    
                                
    • 
                                
  • openSession()与getCurrentSession()区别：
                                    hetongfei
javaDAOHibernate
                                    
    来自 http://blog.csdn.net/dy511/article/details/6166134 
1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。 
2. getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭。 
这里getCurrentSession本地事务(本地
    
                                
    • 
                                
  • 第一章 安装Nginx+Lua开发环境
                                    jinnianshilongnian
nginxluaopenresty
                                    
    首先我们选择使用OpenResty，其是由Nginx核心加很多第三方模块组成，其最大的亮点是默认集成了Lua开发环境，使得Nginx可以作为一个Web Server使用。借助于Nginx的事件驱动模型和非阻塞IO，可以实现高性能的Web应用程序。而且OpenResty提供了大量组件如Mysql、Redis、Memcached等等，使在Nginx上开发Web应用更方便更简单。目前在京东如实时价格、秒
    
                                
    • 
                                
  • HSQLDB In-Process方式访问内存数据库
                                    liyonghui160com

                                    
      
  
HSQLDB一大特色就是能够在内存中建立数据库，当然它也能将这些内存数据库保存到文件中以便实现真正的持久化。 
  
先睹为快！ 
  
下面是一个In-Process方式访问内存数据库的代码示例： 
  
  
下面代码需要引入hsqldb.jar包 （hsqldb-2.2.8） 
  
import java.s
    
                                
    • 
                                
  • Java线程的5个使用技巧
                                    pda158
java数据结构
                                    
    Java线程有哪些不太为人所知的技巧与用法？   　　萝卜白菜各有所爱。像我就喜欢Java。学无止境，这也是我喜欢它的一个原因。日常 
工作中你所用到的工具，通常都有些你从来没有了解过的东西，比方说某个方法或者是一些有趣的用法。比如说线程。没错，就是线程。或者确切说是Thread这个类。当我们在构建高可扩展性系统的时候，通常会面临各种各样的并发编程的问题，不过我们现在所要讲的可能会略有不同。   
    
                                
    • 
                                
  • 开发资源大整合：编程语言篇——JavaScript（1）
                                    shoothao
JavaScript
                                    
    概述：本系列的资源整合来自于github中各个领域的大牛，来收藏你感兴趣的东西吧。           
  程序包管理器  
  管理javascript库并提供对这些库的快速使用与打包的服务。 
 
  Bower - 用于web的程序包管理。 
  component - 用于客户端的程序包管理，构建更好的web应用程序。 
  spm - 全新的静态的文件包管
    
                                
    • 
                                
  • 避免使用终结函数
                                    vahoa.ma
javajvmC++
                                    
    终结函数（finalizer）通常是不可预测的，常常也是很危险的，一般情况下不是必要的。使用终结函数会导致不稳定的行为、更差的性能，以及带来移植性问题。不要把终结函数当做C++中的析构函数（destructors）的对应物。 
  
    我自己总结了一下这一条的综合性结论是这样的： 
1）在涉及使用资源，使用完毕后要释放资源的情形下，首先要用一个显示的方
    
                                
    •