大数据之路week03--day05（线程 I）

真的，身体这个东西一定要爱护好，难受的时候电脑都不想去碰，尤其是胃和肾。。。

这两天耽误了太多时间，今天好转了立刻学习，即刻不能耽误！、

话不多说，说正事：

1、多线程（理解）

　　（1）多线程：一个应用程序有多条执行路径

　　　　  进程：正在执行的应用程序

　　　　  线程：进程的执行单元，或者说是执行路径

　　　　  单线程：一个应用程序只有一条执行路径

　　　　  多线程：一个应用程序有多条执行路径

 

　　　　多进程的意义何在？

　　　　　　提高CPU的使用率

　　　　多线程的意义何在？

　　　　　　提高应用程序的使用率

问题：

　　一边玩游戏，一边听歌时同时进行的吗？

　　　　不是，因为单CPU在某一个时间点上只能做一件事。

　　　　而我们在玩游戏，或者听歌的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。

　　

　　（2）Java程序的运行原理及JVM的启动是多线程的吗？

　　　　A：Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。

　　　　B： JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。

　　　　　　两个词汇：并行和并发

　　　　　　　　并行是逻辑上同时发生，指在某一个时间段内同时运行多个程序。

　　　　　　　　并发是物理上同时发生，指在某一个时间点同时运行多个程序。

　　　　　　高并发：在某个时间点上很多人去访问一个（大数据）

　　（3）多线程的实现方案

　　　　A: 继承Thread类

　　　　　　步骤：　　　

　　　　　　　　1、自定义类MyThread继承Thread类

　　　　　　　　2、MyThread类里面重写run()

　　　　　　　　3、创建对象

　　　　　　　　4、启动线程

MyThread类

package com.wyh.Thread01;

/** 
* @author WYH
* @version 2019年11月22日 下午3:04:30
*/
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int x = 0; x<500;x++) {
            System.out.println(x);
        }
    }

}

测试类：

package com.wyh.Thread01;

/** 
* @author WYH
* @version 2019年11月22日 下午3:05:18
*/
public class ThreadDemo01 {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        
        my1.start();
        my2.start();
    }
    

}

　　　　B: 实现Runnable接口

　　　　　　　　1、自定义类MyThread实现Runnable接口

　　　　　　　　2、MyThread类里面重写run()

　　　　　　　　3、创建对象

　　　　　　　　4、创建Thread对象，把MyThread对象当作参数传入

　　　　　　　　5、启动线程

Runnable类

package com.wyh.Thread04;

/**
 * @author WYH
 * @version 2019年11月22日 下午7:00:06
 */
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int x = 1; x <= 500; x++) {
            System.out.println(Thread.currentThread().getName() + "--" + x);
        }

    }

}

测试类：

package com.wyh.Thread04;

/** 
* @author WYH
* @version 2019年11月22日 下午7:01:07
*/
public class MyRunnableDemo {
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my,"王友虎");
        Thread t2 = new Thread(my,"赵以浩");
        
        t1.start();
        t2.start();
        
    }

}

　　（4）线程的调度和优先级问题

　　　　A：线程的调度

　　　　　　a：分时调度

　　　　　　b：抢占式调度（Java采用的是该调度方式）

　　　　B：获取和设置线程的优先级

　　　　　　a：默认是5

　　　　　　b：范围是1-10

　　（5）线程的控制（常见方法）

　　　　A：休眠线程（测试类在这不写，基本不变）

package com.wyh.Thread03;

import java.util.Date;

/** 
* @author WYH
* @version 2019年11月22日 下午3:04:30
*/
public class ThreadSleep extends Thread {
    public ThreadSleep() {
        super();
        // TODO Auto-generated constructor stub
    }

    public ThreadSleep(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void run() {
        for(int x = 0; x<500;x++) {
            System.out.println(getName()+x+" 日期:"+new Date());
            //睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }

}

　　　　B：加入线程（run方法类不变）

package com.wyh.Thread03;

/** 
* @author WYH
* @version 2019年11月22日 下午3:05:18
* 
* join 为了让某些线程执行完毕，才能执行其他的(线程加入)
* 
* 
* 
*/
public class ThreadJoinDemo {
    public static void main(String[] args) {
        
        ThreadPriority my1 = new ThreadPriority("王友虎");
        ThreadPriority my2 = new ThreadPriority("李宏灿");
        ThreadPriority my3 = new ThreadPriority("齐博源");
        
        my1.start();
        try {
            my1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        my2.start();
        my3.start();
        
    }
    

}

　　　　C：礼让线程（省略测试类代码）

package com.wyh.Thread03;

/** 
* @author WYH
* @version 2019年11月22日 下午4:28:15
*/
public class ThreadYield extends Thread {
    public ThreadYield() {
        super();
        // TODO Auto-generated constructor stub
    }

    public ThreadYield(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void run() {
        for(int x = 0; x<200;x++) {
            System.out.println(getName()+x);
            Thread.yield();
        }
    }
}

　　　　D：后台线程（省略继承类的代码）//注意！！！！必须在启动前声明

package com.wyh.Thread03;

/**
 * @author WYH
 * @version 2019年11月22日 下午4:42:16
 * 
 * 守护线程
 * 
 * 理解：坦克大战，黄绿坦克守护家，家没了，坦克也没了
 * 
 */
public class ThreadDeamonDemo {
    public static void main(String[] args) {
        ThreadDeamon td1 = new ThreadDeamon("关羽");
        ThreadDeamon td2 = new ThreadDeamon("张飞");
        
        
        //注意！！！！必须在启动前声明
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();

        
        
        
        Thread.currentThread().setName("刘备");
        for (int x = 0; x < 5; x++) {
            System.out.println(Thread.currentThread().getName() + x);
        }
    }

}

　　　　E：终止线程（不推荐使用stop，而且该方法已经过时，推荐使用interrupt）

继承类：

package com.wyh.Thread03;

import java.util.Date;

/** 
* @author WYH
* @version 2019年11月22日 下午4:57:38
*/
public class ThreadStop extends Thread{
    @Override
    public void run() {
        System.out.println("时间："+new Date());
        
        //睡眠10秒钟
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.err.println("睡眠被意外中止！！");
        }
        
        System.out.println("时间："+new Date());
        
    }
}

测试类：

package com.wyh.Thread03;

/** 
* @author WYH
* @version 2019年11月22日 下午5:00:21
*/
public class ThreadStopDemo {
    public static void main(String[] args) {
        ThreadStop ts = new ThreadStop();
        ts.start();
        
        try {
            Thread.sleep(3000);
//            ts.stop();  //不建议使用  因为后面的代码无法执行
            ts.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        
    }

}

　　（6）线程的生命周期（图解）

　　（7）电影院卖票程序的实现

　　　　　　A：继承Thread类

继承类：

package com.wyh.Thread05;

/** 
* @author WYH
* @version 2019年11月22日 下午7:33:38
*/
public class SellTicket extends Thread {
    private static int tickets = 100;
    
    @Override
    public void run() {
        while(true) {
            if(tickets>0) {
                System.out.println(getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
            }
            
        }
    }
}

测试类：

package com.wyh.Thread05;

/** 
* @author WYH
* @version 2019年11月22日 下午7:36:19
*/
public class TicketDemo {
    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();
        
        
        
    }

}

　　　　　　B：实现Runnable接口

实现Runnable接口类：

package com.wyh.Thread05;

/** 
* @author WYH
* @version 2019年11月22日 下午7:42:37
*/
public class SellTicket_Runnable implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        while(true) {
            if(tickets>0) {
                System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
            }
        }

    }

}

测试类：

package com.wyh.Thread05;

/** 
* @author WYH
* @version 2019年11月22日 下午7:43:48
*/
public class SellTicket_RunnableDemo {
    public static void main(String[] args) {
        SellTicket_Runnable sr = new SellTicket_Runnable();
        
        Thread t1 = new Thread(sr,"窗口1");
        Thread t2 = new Thread(sr,"窗口2");
        Thread t3 = new Thread(sr,"窗口3");
        
        t1.start();
        t2.start();
        t3.start();
        
    }

}

　　（8）电影院卖票程序出的问题

　　　　A：为了更加符合真实场景，加入了休眠100毫秒。

　　　　B：买票问题

　　　　　　a：同票被多次出售

　　　　　　b：出现0票和负数票

　　（9）多线程安全问题的原因（也是我们以后判断一个程序是否有安全问题的依据）

　　　　A：是否有多线程环境

　　　　B：是否有共享数据

　　　　C：是否有多条语句操作共享数据

　　（10）同步解决线程安全问题（以解决上面售票的为例解决）

　　　　A：同步代码块

　　　　　　　　synchronized(对象){

　　　　　　　　　　需要被同步的代码；

　　　　　　　　}

　　　　　　这里的对象可以是任意对象（充当锁的作用，下面也是相同作用）

实现接口类：（测试类代码不变）

package com.wyh.Thread06_tickets;

/** 
* @author WYH
* @version 2019年11月22日 下午7:42:37
*/
public class SellTicket_Runnable implements Runnable {
    private int tickets = 300;
    private Object obj = new Object();  //如同一把锁 多个线程共用一把锁，把对共享数据的操作包起来

    @Override
    public void run() {
        while(true) {
            synchronized(obj) {
                if(tickets>0) {
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
                }
            }
            
        }

    }

}

　　　　B：同步方法

　　　　　　把同步放在方法上。

　　　　　　这里的锁对象是 this

实现接口类：（测试类代码不变）

package com.wyh.Thread07_tickets2_同步方法静态;

/** 
* @author WYH
* @version 2019年11月22日 下午7:42:37
*/
public class SellTicket_Runnable implements Runnable {
    private int tickets = 300;
    private int x = 0;
    
    //用obj对象做锁
    private Object obj = new Object();  //如同一把锁 多个线程共用一把锁，把对共享数据的操作包起来
    

    @Override
    public void run() {
        if(x%2==0) {
            while(true) {
                synchronized(this) {
                    if(tickets>0) {
                        try {
                            Thread.sleep(30);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
                    }
                }
                
            }
        }else {
                synchronize();
        }
        

    }


    private synchronized void synchronize() {
        while(true) {
                if(tickets>0) {
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
                }
            
        }
        
    }
}

　　　　C：静态同步方法

　　　　　　　把同步加在方法上。

　　　　　　　这里的锁对象是当前类的字节码文件对象（反射）

package com.wyh.Thread07_tickets2_同步方法静态;

/** 
* @author WYH
* @version 2019年11月22日 下午7:42:37
*/
public class SellTicket_Runnable2 implements Runnable {
    private static int tickets = 300;
    private int x = 0;
    
    

    @Override
    public void run() {
        if(x%2==0) {
            while(true) {
                synchronized(SellTicket_Runnable2.class) {
                    if(tickets>0) {
                        try {
                            Thread.sleep(30);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
                    }
                }
                
            }
        }else {
                synchronize();
        }
        

    }


    private synchronized static void synchronize() {
        while(true) {
                if(tickets>0) {
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
                }
            
        }
        
    }
}

·　　（11）回顾以前的线程安全的类

　　　　　　A：StringBuffer

　　　　　　B：Vector

　　　　　　C：HashTable

　　　　　　D：如何把一个线程不安全的集合变成一个线程安全的集合类

　　　　　　　　　　用Collections 工具类的方法即可。

以List集合为例：其他集合创建方法类似，具体看API

package Collections保证线程安全的;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/** 
* @author WYH
* @version 2019年11月22日 下午9:10:58
*/
public class Demo {
    public static void main(String[] args) {
        //以List集合为例
        //以前的我们是这么做的
        List<String> list1 = new ArrayList<String>(); //这么创建的List是不安全的
        
        
        
        //Collections 工具类提供的方法 同步安全的
        List<String> list2 = Collections.synchronizedList(new ArrayList<String>());
        
        list2.add("1");
        list2.add("2");
        
        for(String s : list2) {
            System.out.println(s);
        }
    }

}

 

 

线程中需要注意的问题：

　　1、Thread中start（）方法的功能就是创建一个新的线程，并自动调用该线程的run（）方法，直接调用run（）方法是不会创建一个新的线程的,直接调用相当于调用一个普通方法。

　　2、执行一个线程实际就是执行该线程run方法中的代码

　　3、一个Thread对象只能代表一个线程。

　　    一个Thread对象不能调用两次start（）方法，否则会抛出java.lang.IllegalThreadStateException异常