多线程

　　——- android培训、java培训、期待与您交流！ ———-

一、多线程
(1)多线程：一个应用程序有多条执行路径
进程：正在执行的应用程序
线程：进程的执行单元，执行路径
单线程：一个应用程序只有一条执行路径
多线程：一个应用程序有多条执行路径

多进程的意义?
提高CPU的使用率
多线程的意义?
提高应用程序的使用率

(2)Java程序的运行原理及JVM的启动是多线程的吗?
A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程

(3)多线程的实现方案
A:继承Thread类
B:实现Runnable接口
(4)线程的调度和优先级问题
A:线程的调度
a:分时调度
b:抢占式调度 (Java采用的是该调度方式)
B:获取和设置线程优先级
a:默认是5
b:范围是1-10

(5)线程的控制
A:休眠线程
B:加入线程
C:礼让线程
D:后台线程
E:终止线程

(6)线程的生命周期
A:新建
B:就绪
C:运行
D:阻塞
E:死亡

(7)电影院卖票程序的实现
A:继承Thread类
B:实现Runnable接口

package cn.itcast_09;

public class SellTicket implements Runnable {
    // 定义100张票
    private int tickets = 100;
    //创建锁对象
    private Object obj = new Object();

//  @Override
//  public void run() {
//      while (true) {
//          synchronized(new Object()){
//              if (tickets > 0) {
//                  try {
//                      Thread.sleep(100); 
//                  } catch (InterruptedException e) {
//                      e.printStackTrace();
//                  }
//                  System.out.println(Thread.currentThread().getName() + "正在出售第"
//                          + (tickets--) + "张票");
//              }
//          }
//      }
//  }

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + "正在出售第" + (tickets--) + "张票");
                }
            }
        }
    }
}

package cn.itcast_09;

/*
 * 如何解决线程安全问题呢?
 * 
 * 要想解决问题，就要知道哪些原因会导致出问题:(而且这些原因也是以后我们判断一个程序是否会有线程安全问题的标准)
 * A:是否是多线程环境
 * B:是否有共享数据
 * C:是否有多条语句操作共享数据
 * 
 * 我们来回想一下我们的程序有没有上面的问题呢?
 * A:是否是多线程环境   是
 * B:是否有共享数据    是
 * C:是否有多条语句操作共享数据  是
 * 
 * 由此可见我们的程序出现问题是正常的，因为它满足出问题的条件。
 * 接下来才是我们要想想如何解决问题呢?
 * A和B的问题我们改变不了，我们只能想办法去把C改变一下。
 * 思想：
 *      把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，别人不能来执行。
 * 问题是我们不知道怎么包啊?其实我也不知道，但是Java给我们提供了：同步机制。
 * 
 * 同步代码块：
 *      synchronized(对象){
 *          需要同步的代码;
 *      }
 * 
 *      A:对象是什么呢?
 *          我们可以随便创建一个对象试试。
 *      B:需要同步的代码是哪些呢?
 *          把多条语句操作共享数据的代码的部分给包起来
 * 
 *      注意：
 *          同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
 *          多个线程必须是同一把锁。
 */
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();
    }
}

(8)电影院卖票程序出问题
A:为了更符合真实的场景，加入了休眠100毫秒。
B:卖票问题
a:同票多次
b:负数票

package cn.itcast_10;

public class SellTicket implements Runnable {

    // 定义100张票
    private int tickets = 100;

    // 定义同一把锁
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            // t1,t2,t3都能走到这里
            // 假设t1抢到CPU的执行权，t1就要进来
            // 假设t2抢到CPU的执行权，t2就要进来,发现门是关着的，进不去。所以就等着。
            // 门(开,关)
            synchronized (obj) { // 发现这里的代码将来是会被锁上的，所以t1进来后，就锁了。(关)
                if (tickets > 0) {
                    try {
                        Thread.sleep(100); // t1就睡眠了
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + "正在出售第" + (tickets--) + "张票 ");
                    //窗口1正在出售第100张票
                }
            } //t1就出来可，然后就开门。(开)
        }
    }
}

package cn.itcast_10;

/*
 * 举例：
 *      火车上厕所。
 * 
 * 同步的特点：
 *      前提：
 *          多个线程
 *      解决问题的时候要注意：
 *          多个线程使用的是同一个锁对象
 * 同步的好处 
 *      同步的出现解决了多线程的安全问题。
 * 同步的弊端
 *      当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
 */
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();
    }
}

(9)多线程安全问题的原因(也是我们以后判断一个程序是否有线程安全问题的依据)
A:是否有多线程环境
B:是否有共享数据
C:是否有多条语句操作共享数据
(10)同步解决线程安全问题
A:同步代码块
synchronized(对象) {
需要被同步的代码;
}

这里的锁对象可以是任意对象。

B:同步方法
把同步加在方法上。

这里的锁对象是this

C:静态同步方法
把同步加在方法上。

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

package cn.itcast_11;

public class SellTicket implements Runnable {

    // 定义100张票
    private static int tickets = 100;

    // 定义同一把锁
    private Object obj = new Object();
    private Demo d = new Demo();

    private int x = 0;

    //同步代码块用obj做锁
//  @Override
//  public void run() {
//      while (true) {
//          synchronized (obj) {
//              if (tickets > 0) {
//                  try {
//                      Thread.sleep(100);
//                  } catch (InterruptedException e) {
//                      e.printStackTrace();
//                  }
//                  System.out.println(Thread.currentThread().getName()
//                          + "正在出售第" + (tickets--) + "张票 ");
//              }
//          }
//      }
//  }

    //同步代码块用任意对象做锁
//  @Override
//  public void run() {
//      while (true) {
//          synchronized (d) {
//              if (tickets > 0) {
//                  try {
//                      Thread.sleep(100);
//                  } catch (InterruptedException e) {
//                      e.printStackTrace();
//                  }
//                  System.out.println(Thread.currentThread().getName()
//                          + "正在出售第" + (tickets--) + "张票 ");
//              }
//          }
//      }
//  }

    @Override
    public void run() {
        while (true) {
            if(x%2==0){
                synchronized (SellTicket.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()
                                + "正在出售第" + (tickets--) + "张票 ");
                    }
                }
            }else {
//              synchronized (d) {
//                  if (tickets > 0) {
//                      try {
//                          Thread.sleep(100);
//                      } catch (InterruptedException e) {
//                          e.printStackTrace();
//                      }
//                      System.out.println(Thread.currentThread().getName()
//                              + "正在出售第" + (tickets--) + "张票 ");
//                  }
//              }

                sellTicket();

            }
            x++;
        }
    }

//  private void sellTicket() {
//      synchronized (d) {
//          if (tickets > 0) {
//          try {
//                  Thread.sleep(100);
//          } catch (InterruptedException e) {
//                  e.printStackTrace();
//          }
//          System.out.println(Thread.currentThread().getName()
//                      + "正在出售第" + (tickets--) + "张票 ");
//          }
//      }
//  }

    //如果一个方法一进去就看到了代码被同步了，那么我就再想能不能把这个同步加在方法上呢?
//   private synchronized void sellTicket() {
//          if (tickets > 0) {
//          try {
//                  Thread.sleep(100);
//          } catch (InterruptedException e) {
//                  e.printStackTrace();
//          }
//          System.out.println(Thread.currentThread().getName()
//                      + "正在出售第" + (tickets--) + "张票 ");
//          }
//  }

    private static synchronized void sellTicket() {
        if (tickets > 0) {
        try {
                Thread.sleep(100);
        } catch (InterruptedException e) {
                e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
                    + "正在出售第" + (tickets--) + "张票 ");
        }
}
}

class Demo {
}

package cn.itcast_11;

/*
 * A:同步代码块的锁对象是谁呢?
 *      任意对象。
 * 
 * B:同步方法的格式及锁对象问题?
 *      把同步关键字加在方法上。
 * 
 *      同步方法是谁呢?
 *          this
 * 
 * C:静态方法及锁对象问题?
 *      静态方法的锁对象是谁呢?
 *          类的字节码文件对象。(反射会讲)
 */
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();
    }
}

(11)回顾以前的线程安全的类
A:StringBuffer
B:Vector
C:Hashtable
D:如何把一个线程不安全的集合类变成一个线程安全的集合类
用Collections工具类的方法即可。

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

public class ThreadDemo {
    public static void main(String[] args) {
        // 线程安全的类
        StringBuffer sb = new StringBuffer();
        Vector<String> v = new Vector<String>();
        Hashtable<String, String> h = new Hashtable<String, String>();

        // Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
        // 那么到底用谁呢?
        // public static <T> List<T> synchronizedList(List<T> list)
        List<String> list1 = new ArrayList<String>();// 线程不安全
        List<String> list2 = Collections
                .synchronizedList(new ArrayList<String>()); // 线程安全
    }
}

　　——- android培训、java培训、期待与您交流！ ———-