大数据预科19（补充之线程）

叁歲伎倆 2022-06-06 14:11 70阅读 0赞

# 线程 #

###  ###

*  进程
    
     *  进程指正在运行的程序。确切的说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定的独立功能
     *  服务（没有界面的进程）
 *  线程
    
     *  线程是进程中的一个执行单元，负责当前进程中程序的执行。一个进程中至少有一个线程。一个进程中可以有多个线程，这个应用可以称之为多线程程序。
 *  程序运行原理
    
     *  分时调度
        
         *  所有的线程轮流使用cpu的使用权，平均分配每个线程占用cpu的使用时间。
     *  抢占式调度
        
         *  优先级高的线程先执行，如果优先级相同，那么会随机选择一个线程来执行，java使用的为抢占式调度
 *  实际上
    
     *  cpu使用抢占式调度模式在多个线程间进行着高速的切换，对于cpu的一个核而言，某个时刻，只能执行一个线程，而cpu的多个线程间切换速度相对我们来说很快，看上去就像是同一时刻在运行。
     *  其实，多线程并不能提高程序的运行速度，但能提高程序的运行效率，让cpu的使用率更高
 *  主线程
    
     *  jvm启动后，必然有一个执行路径（线程）从main方法执行，一直执行到main方法结束，这个线程称为主线程

### Thread类 ###

*  创建线程的方式
    
     *  继承Thread类，重写run方法，创建对象，然后开启线程
     *  实现Runnable接口，重写run方法，然后创建Runnable实现类的对象，传入到某现成的构造方法中，开启线程。
 *  创建线程之-继承Thread
    
    1.  定义一个类继承Thread
    2.  重写run方法
    3.  创建子类对象，就是创建线程对象
    4.  调用start方法，开启线程并让线程执行，同时还会告诉jvm去掉用run方法 //自定义线程类 public class MyThread\{ public MyThread(String name)\{ super(name); \} //重写run方法 Override public void run()\{ //逻辑代码 \} \}
 *  创建线程之实现Runnable接口，创建实现类对象，传入到Thread中
    
    1.  定义类实现Runnable接口
    2.  覆盖接口中的run方法
    3.  创建Thread对象
    4.  将Runnable接口的子类对象作为参数传递给Thread类的构造函数
    5.  调用Thread的start方法开启线程 //自定义线程类 public class MyRunnable implements Runnable\{ @Override public void run()\{ //逻辑代码 \} \}
 *  思考：线程对象调用run方法和调用start方法有什么不同--线程调用run方法不开启线程，仅是对象调用方法。线程调用start方法，并让jvm调用run方法
 *  继承Thred类原理
    
     *  问题：为什么不直接用Thread来创建对象并调用方法，而是用Thread的子类来创建对象呢？
        
         *  可以用Thread来创建对象，但是Thread的run方法并没有逻辑，没有具体的意义。
     *  创建线程的目的是什么？
        
         *  是为了建立程序单独的执行路径，让部分代码实现同时执行，
 *  多线程的内存图解
    
     *  栈内存中，每一个线程都有一片自己的栈内存空间，进行方法的压栈与弹栈
 *  获取线程的名称
    
     *  Thread.currentThread().getName();
     *  主线程的名称为main
     *  自定义的线程Thread-0数字顺延
 *  实现Runnable的原理
    
     *  为了避免Thread类的单继承的局限性，
     *  线程对象与线程任务相分离，进行解耦
 *  线程内部类的的使用
    
     *  Thread
        
        #  #
        
            newThread(){
                public void run(){
                    //逻辑
                }
            }.start();
     *  Runnable

### 线程池 ###

*  概念
    
     *  线程池，其实就是一个容纳一个多线程的容器，其中的线程可以反复使用，省去了频繁创建对象的操作，无须反复创建而消耗过多资源
 *  解决问题
    
     *  线程声明周期的开销问题--创建和销毁
     *  资源不足问题--内存是有限的
 *  线程创建的流程--Runnable

#  #

1. 创建线程池对象
        1. ExecutorService service= Executors.newFixedThreadPool(2);
    2. 创建Runnable实例对象
        1. MyRunnable r=new MyRunnable();
    3. 从线程池中获取线程
        1. service.submit(r);
        2. service.submit(r);
    4. 关闭线程池
        1. service.shutdown();

*  线程创建的流程--Callable接口

#  #

1. 创建线程池对象
        1. ExecutorService service=Executors.newFixedThreadPool(2);
    2. 创建Callable对象
        1. MyCallable c=new MyCallable();
    3. 从线程池中获取对象，然后调用MyCallable中的run方法
        1. service.submit(c);
    4. 关闭线程池
        1. service.shutdown();
    
    //MyCallable类
    public Object MyCallable{
        @Override
        public Object call() throws Exception{
            //逻辑
        }
    }

### 练习 ###

*  线程池练习，返回两个数相加的结果（Callable）

#  #

//Callab接口实现类
    public class MyCallable implements Callable<Integer>{
        //成员变量
        int x=5;
        int y=3;
    
        //构造方法
        public MyCallable(){
    
        }
    
        public MyCallable(int x,int y){
            this.x=x;
            this.y=y;
        }
    
        @Override
        public Integer call() throws Exception{
            return x+y;
        }
    }
    
    //主函数
    public static void main(String[] args) throws InterruptedException,ExcutionException{
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        //创建一个Callable接口子类对象
        MyCallable c1=new MyCallable(100,200);
        MyCallable c1=new MyCallable(10,20);
        //获取线程池中的线程，调用call方法，完成求和操作
        Future<Integer> result = threadPool.submit(c1);
        Integer sum = result.get();
        System.out.println("sum="+sum);
    
        result = threadpool.submit(c2);
        sum=result.get();
        System.out,.ptintln("sum="+sum);
    }

### 同步方式--同步代码块 ###

#  #

package com.peng.demo;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * @author kungfu~peng
     * @data 2017年9月26日
     * @description
     */
    public class Testtt {
        public static void main(String[] args) {
            Ticket tic1 = new Ticket();
            Ticket tic2 = new Ticket();
            Ticket tic3 = new Ticket();
            new Thread(tic1).start();
            new Thread(tic2).start();
            new Thread(tic3).start();
        }
    }
    
    class Ticket implements Runnable {
        // 共100票
        int ticket = 100;
        Object lock = new Object();
    
        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Runnable#run()
         */
        @Override
        public void run() {
            // 模拟买票
            while (true) {
                synchronized (lock) {
                    if (ticket > 0) {
                        // 模拟选座的操作
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread() + "正在买票："
                                + ticket--);
                    }
                }
            }
        }
    
    }

### 同步方法 ###

#  #

package com.peng.demo;
    
    
    /**
     * @author kungfu~peng
     * @data 2017年9月26日
     * @description
     */
    public class Testtt {
        public static void main(String[] args) {
            Ticket tic1 = new Ticket();
            Ticket tic2 = new Ticket();
            Ticket tic3 = new Ticket();
            new Thread(tic1).start();
            new Thread(tic2).start();
            new Thread(tic3).start();
        }
    }
    
    class Ticket implements Runnable {
        // 共100票
        int ticket = 100;
    
        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Runnable#run()
         */
        @Override
        public void run() {
            // 模拟买票
            while (true) {
                method();
            }
        }
    
        public synchronized void method() {
            if (ticket > 0) {
                // 模拟选座的操作
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "正在买票：" + ticket--);
            }
        }
    }

### 同步代码块--锁 ###

#  #

package com.peng.demo;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * @author kungfu~peng
     * @data 2017年9月26日
     * @description
     */
    public class Testtt {
        public static void main(String[] args) {
            Ticket tic1 = new Ticket();
            Ticket tic2 = new Ticket();
            Ticket tic3 = new Ticket();
            new Thread(tic1).start();
            new Thread(tic2).start();
            new Thread(tic3).start();
        }
    }
    
    class Ticket implements Runnable {
        // 共100票
        int ticket = 100;
        // 创建Lock锁对象
        Lock ck = new ReentrantLock();
        Object lock = new Object();
    
        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Runnable#run()
         */
        @Override
        public void run() {
            // 模拟买票
            while (true) {
                ck.lock();
                if (ticket > 0) {
                    // 模拟选座的操作
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread() + "正在买票：" + ticket--);
                }
                ck.unlock();
            }
        }
    
    }

### 静态同步方法中的锁对象是：类名.class ###

#  #

public static synchronized int setName(String name){
          Xxx.name = name;
    }
    等价于
    public static int setName(String name){
          synchronized(Xxx.class){
                Xxx.name = name;
          }
    } 
    //注意一定不能用this

### 死锁 ###

*  同步锁的使用弊端：当线程任务中出现了多个同步（多个锁）时，如果同步中嵌套了其他的同步，容易引发一种现象：程序出现无限等待，这种现象称为死锁。

#  #

synchronzied(A锁){
            synchronzied(B锁){
    
            }
    }

*  原因：多个线程；共享资源过多；锁对象不统一；锁的嵌套

### 等待唤醒机制 ###

*  wait等待--将正在执行的线程释放其执行资格和执行权，并存储到线程池中。
 *  notify唤醒，唤醒线程池被wait的线程，一次唤醒一个，而且是任意的
 *  notifyAll唤醒全部，可以将线程池中的所有的wait的线程都唤醒

#  #

//唤醒机制
    
    //模拟资源类
    package com.peng.demo;
    
    /**
     * @author kungfu~peng
     * @data 2017年9月26日
     * @description
     */
    public class Resources {
        private String name;
        private String sex;
        private boolean flag = false;
    
        public synchronized void set(String name, String sex) {
            if (flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 设置成员变量
                this.name = name;
                this.sex = sex;
                // 设置之后，Resources中有值，将标记改为true
                flag = true;
                // 唤醒output
                this.notify();
            }
        }
    
        public synchronized void out() {
            if (!flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 输出线程将数据输出
                System.out.println("姓名：" + name + ",性别：" + sex);
                // 改变标记，以便通知线程输入数据
                flag = false;
                // 唤醒input，进行数据输入
                this.notifyAll();//这里用this.notify()的话，当多个线程同时开启，会产生无限等待
            }
        }
    }

#  #

//输入线程类
    class Input implements Runnable{
        private Resource r;
        public Input(Resource r){
            this.r=r;
        }
    
        @Override
        public void run(){
            int count=0;
            while(true){
                if(count%2==0){
                    r.set("小明","男生");
                }else(){
                    r.set("小花","女生");
                }
                count++;    
            }
        }
    }

#  #

//线程输出类
    class Output{
        private Resource r;
        public Input(Resource r){
            this.r=r;
        }
    
        @Override
        public void run(){
            while(true){
                r.out();    
            }
        }
    }

#  #

//测试类
    package com.peng.demo;
    
    /**
     * @author kungfu~peng
     * @data 2017年9月26日
     * @description 测试类
     */
    public class ResourcesDemo {
        public static void main(String[] args) {
            // 资源对象
            Resources r = new Resources();
            // 任务对象
            Input in = new Input(r);
            Output out = new Output(r);
            // 线程对象
            Thread t1 = new Thread(in);
            Thread t2 = new Thread(out);
            // 开启线程
            t1.start();
            t2.start();
        }
    }

### 线程状态 ###

*  新建状态->就绪状态<->运行状态->死亡状态
 *  其他阻塞、同步阻塞、等待组阻塞

### 补充 ###

*  同步一定安全，不安全一定是异步
    
     *  HashMap异步式线程不安全：对整个map不加以限制，线程都可操作
     *  HashTable同步式线程安全：线程把整的map都锁起来
     *  ConcurrentHashMap异步式线程安全：线程把map中的一个Entry锁起来
 *  sleep与wait的区别？
    
     *  sleep：
        
         *  需要指定睡眠时间，到自然醒
         *  释放执行权，不释放锁
         *  被设计Thread类中的静态方法
     *  wait：
        
         *  可以指定等待时间（醒来抢不到报错），也可以不指定等待时间
         *  释放执行权，释放锁
         *  被设计为Object的普通方法
         *  必须结合锁来使用--打破锁--【锁对象】和【对象.wait（）】对象一致
 *  线程池：是按队列排序的
 *  阻塞：没有执行代码，但抢占资源
 *  冻结：不执行代码，也不抢占资源
 *  守护线程
    
     *  也称“服务线程”
     *  守护其他线程的执行，当被守护的线程结束，守护线程完成与否，都会随之结束
     *  小兵---保护大bose
     *  线程中，要么是守护线程，要么是被守护的线程
     *  如果出现被守护的线程，那么以最后一个守护的线程为接收标准
     *  GC本质是一个守护进程
     *  Thread.setDaemon(true);//设置为守护线程
     *  必须在start之前设置，否则会抛出一个IllegalThreadStateException
     *  在Daemon线程中产生的新线程也是Daemon的。
     *  不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。
        
        #  #
        
            注意1：
            example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的
            Thread,程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是
            JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于
            实时监控和管理系统中的可回收资源。
            生命周期：守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且
            周期性地执行某种任务或等待处理某些发生的事件。也就是
            说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。那Java的守护线程是
            什么样子的呢。当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个
            或以上的非守护线程则JVM不会退出。
        
        #  #
        
            我们知道静态变量是ClassLoader级别的，如果Web应用程序停止，
            这些静态变量也会从JVM中清除。但是线程则是JVM级别的，如果你在Web 应用中启动一个线程，
            这个线程的生命周期并不会和Web应用程序保持同步。也就是说，即使你停止了Web应用，这个线程依旧是活跃的。
            正是因为这个很隐晦的问题，所以很多有经验的开发者不太赞成在Web应用中私自启动线程
        
        #  #
        
            例子：
            在使用长连接的comet服务端推送技术中，消息推送线程设置为守护线程，
            服务于ChatServlet的servlet用户线程，在servlet的init启动消息线程，
            servlet一旦初始化后，一直存在服务器，servlet摧毁后,消息线程自动退出

容器收到一个Servlet请求，调度线程从线程池中选出一个工作者线程,将请求传递给该工作者线程，然后由该线程来执行Servlet的 service方法。当这个线程正在执行的时候,容器收到另外一个请求,调度线程同样从线程池中选出另一个工作者线程来服务新的请求,容器并不关心这个请求是否访问的是同一个Servlet.当容器同时收到对同一个Servlet的多个请求的时候，那么这个Servlet的service()方法将在多线程中并发执行。 Servlet容器默认采用单实例多线程的方式来处理请求，这样减少产生Servlet实例的开销，提升了对请求的响应时间，对于Tomcat可以在server.xml中通过元素设置线程池中线程的数目。

### 线程的优先级 ###

*  线程有10个优先级（1-10）
 *  优先级越高，理论上线程抢到的资源的概率越高
 *  两个优先级差5个等级才有所区别，否则优先级差不多