大数据之路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类

 1 package com.wyh.Thread01;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午3:04:30
 6 */
 7 public class MyThread extends Thread {
 8     @Override
 9     public void run() {
10         for(int x = 0; x<500;x++) {
11             System.out.println(x);
12         }
13     }
14 
15 }

测试类:

 1 package com.wyh.Thread01;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午3:05:18
 6 */
 7 public class ThreadDemo01 {
 8     public static void main(String[] args) {
 9         MyThread my1 = new MyThread();
10         MyThread my2 = new MyThread();
11         
12         my1.start();
13         my2.start();
14     }
15     
16 
17 }

    B: 实现Runnable接口

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

        2、MyThread类里面重写run()

        3、创建对象

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

        5、启动线程

Runnable类

 1 package com.wyh.Thread04;
 2 
 3 /**
 4  * @author WYH
 5  * @version 2019年11月22日 下午7:00:06
 6  */
 7 public class MyRunnable implements Runnable {
 8 
 9     @Override
10     public void run() {
11         for (int x = 1; x <= 500; x++) {
12             System.out.println(Thread.currentThread().getName() + "--" + x);
13         }
14 
15     }
16 
17 }

测试类:

 1 package com.wyh.Thread04;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:01:07
 6 */
 7 public class MyRunnableDemo {
 8     public static void main(String[] args) {
 9         MyRunnable my = new MyRunnable();
10         Thread t1 = new Thread(my,"王友虎");
11         Thread t2 = new Thread(my,"赵以浩");
12         
13         t1.start();
14         t2.start();
15         
16     }
17 
18 }

  (4)线程的调度和优先级问题

    A:线程的调度

      a:分时调度

      b:抢占式调度(Java采用的是该调度方式)

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

      a:默认是5

      b:范围是1-10

  (5)线程的控制(常见方法)

    A:休眠线程(测试类在这不写,基本不变)

 1 package com.wyh.Thread03;
 2 
 3 import java.util.Date;
 4 
 5 /** 
 6 * @author WYH
 7 * @version 2019年11月22日 下午3:04:30
 8 */
 9 public class ThreadSleep extends Thread {
10     public ThreadSleep() {
11         super();
12         // TODO Auto-generated constructor stub
13     }
14 
15     public ThreadSleep(String name) {
16         super(name);
17         // TODO Auto-generated constructor stub
18     }
19 
20     @Override
21     public void run() {
22         for(int x = 0; x<500;x++) {
23             System.out.println(getName()+x+" 日期:"+new Date());
24             //睡眠1秒
25             try {
26                 Thread.sleep(1000);
27             } catch (InterruptedException e) {
28                 // TODO Auto-generated catch block
29                 e.printStackTrace();
30             }
31             
32         }
33     }
34 
35 }

    B:加入线程(run方法类不变)

 1 package com.wyh.Thread03;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午3:05:18
 6 * 
 7 * join 为了让某些线程执行完毕,才能执行其他的(线程加入)
 8 * 
 9 * 
10 * 
11 */
12 public class ThreadJoinDemo {
13     public static void main(String[] args) {
14         
15         ThreadPriority my1 = new ThreadPriority("王友虎");
16         ThreadPriority my2 = new ThreadPriority("李宏灿");
17         ThreadPriority my3 = new ThreadPriority("齐博源");
18         
19         my1.start();
20         try {
21             my1.join();
22         } catch (InterruptedException e) {
23             // TODO Auto-generated catch block
24             e.printStackTrace();
25         }
26         
27         my2.start();
28         my3.start();
29         
30     }
31     
32 
33 }

    C:礼让线程(省略测试类代码)

 1 package com.wyh.Thread03;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午4:28:15
 6 */
 7 public class ThreadYield extends Thread {
 8     public ThreadYield() {
 9         super();
10         // TODO Auto-generated constructor stub
11     }
12 
13     public ThreadYield(String name) {
14         super(name);
15         // TODO Auto-generated constructor stub
16     }
17 
18     @Override
19     public void run() {
20         for(int x = 0; x<200;x++) {
21             System.out.println(getName()+x);
22             Thread.yield();
23         }
24     }
25 }

    D:后台线程(省略继承类的代码)//注意!!!!必须在启动前声明

 1 package com.wyh.Thread03;
 2 
 3 /**
 4  * @author WYH
 5  * @version 2019年11月22日 下午4:42:16
 6  * 
 7  * 守护线程
 8  * 
 9  * 理解:坦克大战,黄绿坦克守护家,家没了,坦克也没了
10  * 
11  */
12 public class ThreadDeamonDemo {
13     public static void main(String[] args) {
14         ThreadDeamon td1 = new ThreadDeamon("关羽");
15         ThreadDeamon td2 = new ThreadDeamon("张飞");
16         
17         
18         //注意!!!!必须在启动前声明
19         td1.setDaemon(true);
20         td2.setDaemon(true);
21 
22         td1.start();
23         td2.start();
24 
25         
26         
27         
28         Thread.currentThread().setName("刘备");
29         for (int x = 0; x < 5; x++) {
30             System.out.println(Thread.currentThread().getName() + x);
31         }
32     }
33 
34 }

    E:终止线程(不推荐使用stop,而且该方法已经过时,推荐使用interrupt)

继承类:

 1 package com.wyh.Thread03;
 2 
 3 import java.util.Date;
 4 
 5 /** 
 6 * @author WYH
 7 * @version 2019年11月22日 下午4:57:38
 8 */
 9 public class ThreadStop extends Thread{
10     @Override
11     public void run() {
12         System.out.println("时间:"+new Date());
13         
14         //睡眠10秒钟
15         try {
16             Thread.sleep(10000);
17         } catch (InterruptedException e) {
18             System.err.println("睡眠被意外中止!!");
19         }
20         
21         System.out.println("时间:"+new Date());
22         
23     }
24 }

测试类:

 1 package com.wyh.Thread03;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午5:00:21
 6 */
 7 public class ThreadStopDemo {
 8     public static void main(String[] args) {
 9         ThreadStop ts = new ThreadStop();
10         ts.start();
11         
12         try {
13             Thread.sleep(3000);
14 //            ts.stop();  //不建议使用  因为后面的代码无法执行
15             ts.interrupt();
16         } catch (InterruptedException e) {
17             e.printStackTrace();
18         }
19         
20         
21     }
22 
23 }

  (6)线程的生命周期(图解)

  (7)电影院卖票程序的实现

      A:继承Thread类

继承类:

 1 package com.wyh.Thread05;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:33:38
 6 */
 7 public class SellTicket extends Thread {
 8     private static int tickets = 100;
 9     
10     @Override
11     public void run() {
12         while(true) {
13             if(tickets>0) {
14                 System.out.println(getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
15             }
16             
17         }
18     }
19 }

测试类:

 1 package com.wyh.Thread05;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:36:19
 6 */
 7 public class TicketDemo {
 8     public static void main(String[] args) {
 9         //先创建多个线程
10         SellTicket st1 = new SellTicket();
11         SellTicket st2 = new SellTicket();
12         SellTicket st3 = new SellTicket();
13         
14         //给多个线程起名字’
15         st1.setName("窗口1");
16         st2.setName("窗口2");
17         st3.setName("窗口3");
18         
19         st1.start();
20         st2.start();
21         st3.start();
22         
23         
24         
25     }
26 
27 }

      B:实现Runnable接口

实现Runnable接口类:

 1 package com.wyh.Thread05;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:42:37
 6 */
 7 public class SellTicket_Runnable implements Runnable {
 8     private int tickets = 100;
 9 
10     @Override
11     public void run() {
12         while(true) {
13             if(tickets>0) {
14                 System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
15             }
16         }
17 
18     }
19 
20 }

测试类:

 1 package com.wyh.Thread05;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:43:48
 6 */
 7 public class SellTicket_RunnableDemo {
 8     public static void main(String[] args) {
 9         SellTicket_Runnable sr = new SellTicket_Runnable();
10         
11         Thread t1 = new Thread(sr,"窗口1");
12         Thread t2 = new Thread(sr,"窗口2");
13         Thread t3 = new Thread(sr,"窗口3");
14         
15         t1.start();
16         t2.start();
17         t3.start();
18         
19     }
20 
21 }

  (8)电影院卖票程序出的问题

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

    B:买票问题

      a:同票被多次出售

      b:出现0票和负数票

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

    A:是否有多线程环境

    B:是否有共享数据

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

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

    A:同步代码块

        synchronized(对象){

          需要被同步的代码;

        }

      这里的对象可以是任意对象(充当锁的作用,下面也是相同作用)

实现接口类:(测试类代码不变)

 1 package com.wyh.Thread06_tickets;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:42:37
 6 */
 7 public class SellTicket_Runnable implements Runnable {
 8     private int tickets = 300;
 9     private Object obj = new Object();  //如同一把锁 多个线程共用一把锁,把对共享数据的操作包起来
10 
11     @Override
12     public void run() {
13         while(true) {
14             synchronized(obj) {
15                 if(tickets>0) {
16                     try {
17                         Thread.sleep(30);
18                     } catch (InterruptedException e) {
19                         // TODO Auto-generated catch block
20                         e.printStackTrace();
21                     }
22                     System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
23                 }
24             }
25             
26         }
27 
28     }
29 
30 }

    B:同步方法

      把同步放在方法上。

      这里的锁对象是 this

实现接口类:(测试类代码不变)

 1 package com.wyh.Thread07_tickets2_同步方法静态;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:42:37
 6 */
 7 public class SellTicket_Runnable implements Runnable {
 8     private int tickets = 300;
 9     private int x = 0;
10     
11     //用obj对象做锁
12     private Object obj = new Object();  //如同一把锁 多个线程共用一把锁,把对共享数据的操作包起来
13     
14 
15     @Override
16     public void run() {
17         if(x%2==0) {
18             while(true) {
19                 synchronized(this) {
20                     if(tickets>0) {
21                         try {
22                             Thread.sleep(30);
23                         } catch (InterruptedException e) {
24                             // TODO Auto-generated catch block
25                             e.printStackTrace();
26                         }
27                         System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
28                     }
29                 }
30                 
31             }
32         }else {
33                 synchronize();
34         }
35         
36 
37     }
38 
39 
40     private synchronized void synchronize() {
41         while(true) {
42                 if(tickets>0) {
43                     try {
44                         Thread.sleep(30);
45                     } catch (InterruptedException e) {
46                         // TODO Auto-generated catch block
47                         e.printStackTrace();
48                     }
49                     System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
50                 }
51             
52         }
53         
54     }
55 }

    C:静态同步方法

       把同步加在方法上。

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

 1 package com.wyh.Thread07_tickets2_同步方法静态;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月22日 下午7:42:37
 6 */
 7 public class SellTicket_Runnable2 implements Runnable {
 8     private static int tickets = 300;
 9     private int x = 0;
10     
11     
12 
13     @Override
14     public void run() {
15         if(x%2==0) {
16             while(true) {
17                 synchronized(SellTicket_Runnable2.class) {
18                     if(tickets>0) {
19                         try {
20                             Thread.sleep(30);
21                         } catch (InterruptedException e) {
22                             e.printStackTrace();
23                         }
24                         System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
25                     }
26                 }
27                 
28             }
29         }else {
30                 synchronize();
31         }
32         
33 
34     }
35 
36 
37     private synchronized static void synchronize() {
38         while(true) {
39                 if(tickets>0) {
40                     try {
41                         Thread.sleep(30);
42                     } catch (InterruptedException e) {
43                         e.printStackTrace();
44                     }
45                     System.out.println(Thread.currentThread().getName()+"窗口正在售卖第"+(tickets--)+"张票。。");
46                 }
47             
48         }
49         
50     }
51 }

·  (11)回顾以前的线程安全的类

      A:StringBuffer

      B:Vector

      C:HashTable

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

          用Collections 工具类的方法即可。

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

 1 package Collections保证线程安全的;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.List;
 6 
 7 /** 
 8 * @author WYH
 9 * @version 2019年11月22日 下午9:10:58
10 */
11 public class Demo {
12     public static void main(String[] args) {
13         //以List集合为例
14         //以前的我们是这么做的
15         List<String> list1 = new ArrayList<String>(); //这么创建的List是不安全的
16         
17         
18         
19         //Collections 工具类提供的方法 同步安全的
20         List<String> list2 = Collections.synchronizedList(new ArrayList<String>());
21         
22         list2.add("1");
23         list2.add("2");
24         
25         for(String s : list2) {
26             System.out.println(s);
27         }
28     }
29 
30 }

 

 

线程中需要注意的问题:

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

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

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

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

 

posted @ 2019-11-22 22:55  Xiaohu_BigData  阅读(191)  评论(0编辑  收藏  举报