多线程详解和代码测试

1:多线程
(1)多线程：一个应用程序有多条执行路径
进程：正在执行的应用程序。

             是系统进行资源分配和调用的独立单元。每一个进程都有他自己的内存空间和系统资源
线程：进程的执行单元，执行路径。

              在同一个进程内又可以执行多个任务，而这每一个任务就可以视为一个线程。
单线程：一个应用程序只有一条执行路径
多线程：一个应用程序有多条执行路径

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

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

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

(3)多线程的实现方案
A:继承Thread类

/*
 * java提供两两种方式实现多线程程序
 * 
 * 方式一：继承Thred类
 * 步骤：自定义MyThread类 继承Thred类 
 *     MyThread类里面重写run()?
 *        这里要明白为什么是run方法
 *     创建对象
 *     启动线程
 *     
 */
public class MyThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        //MyThread my = new MyThread();
        //启动线程
        //my.run();
        //my.run();
        /*
         * 调用run()方法为什么是单线程的？
         * 由于run()方法直接调用其实就相当于普通的方法调用，所有是单线程的效果
         * 可以通过start()方法来实现多线程
         * 
         * 这里要明白run()和start()的区别：
         * run()：仅是封装被线程执行的代码，直接调用属于普通方法
         * start()：先启动线程，然后再通过jvm去调用该线程的run()方法
         */
        
        //创建两个线程
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        my1.start();
        my2.start();
    }

}

/*
 * 这个类要重写run()方法，是因为，不是说类中的所有代码都需要被线程执行。
 * 这时为了区分哪些代码能够被线程执行，Java就提供了Thread类中的run()方法
 * 来包含哪些需要被线程执行的代码
 */
public class MyThread extends Thread{
    @Override
    public void run(){
        for(int x = 0; x < 100; x++){
            System.out.println(x);
        }
    }

}

获取线程名称

/*
 * 获取线程对象名称
 */
public class MyThredDemo1 {
    public static void main(String[] args) {
        //带参构造方法给线程起名字
        MyThread1 my1 = new MyThread1("a");
        MyThread1 my2 = new MyThread1("b");
        
        //调用方法设置名称
        //my1.setName("a");
        //my2.setName("b");
        
        my1.start();
        my2.start();
        
        //获取main方法所在线程名称
        System.out.println(Thread.currentThread().getName());
    }

}

public class MyThread1 extends Thread{

    public  MyThread1() {
        
    }
    
    public  MyThread1(String name) {
        
    }
    
    @Override
    public void run(){
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);
        }
    }
}

B:实现Runnable接口(一般都会采用方式二)

/*
 * 多线程实现方式2：实现Runnable接口
 * 步骤：1.自定义类MyRunnable实现Runnable接口
 *     2.重写run()方法
 *     3.创建MyRunnable类的对象
 *     4.创建Thread类的对象，并把3步骤的对象作为构造参数传递
 */
public class MyRunnableDemo {
     public static void main(String[] args) {
         //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
        
        //创建Thread类的对象，并把3步骤的对象作为构造参数传递
        //Thread(Runnale target)
        //Thread t1 = new Thread(my);
        //Thread t2 = new Thread(my);
        //t1.setName("aa");
        //t2.setName("bb");
        
        //Thread(Runnable target, String name) 另一种方法命名
        Thread t1 = new Thread(my, "aa");
        Thread t2 = new Thread(my, "bb");
        
        t1.start();
        t2.start();
   }
}

public class MyRunnable implements Runnable {
/*
 * 1.自定义类MyRunnable实现Runnable接口
 * 2.重写run()方法
 * 
 */
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            //由于实现接口的方法不能直接Thread类的方法，这时需要间接使用
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }

    }

}

小结：

实现多线程的方式：两种

方式一：继承Thread类

步骤：1.自定义类MyThread继承Thread类

           2.在MyThread类中重写run()方法

           3.创建MyThread类的对象

           4.启动线程对象

方式二：实现Runnable接口

步骤：1.自定义类MyRunnble实现Runnable接口

           2.MyRunnble里面重写run()方法

           3.创建MyRunnble类的对象

           4.创建Thread类的对象，并把3步骤的对象作为构造参数传递

问题：有了方式一了，为什么还要方式二呢？

          1.可以避免由于Java单继承带来的局限性

          2.适合多个相同程序的代码去处理同一个资源的情况，将线程和程序的代码、数据分离，充分体现了面向对象的设计思想。

(4)线程的调度和优先级问题
    A:线程的调度
      a:分时调度
      b:抢占式调度 (Java采用的是该调度方式)
   B:获取和设置线程优先级
      a:默认是5
      b:范围是1-10

/*
 * 获取线程的优先级
 *    public final int getPriority():返回线程的优先级
 *    
 * 设置线程对象的优先级
 *    public final void setPriority():设置线程优先级
 *    
 * 注意：线程默认的优先级是5
 *     线程优先级范围是：1-10
 *     优先级高仅表示线程获取CPU时间片的几率高，这要求次数比较多或者多次运行才能看到好的效果
 *     
 */
public class ThreadPriorityDemo {

    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();
        
        tp1.setName("aa");
        tp1.setName("bb");
        tp1.setName("cc");
        
        //获取默认优先级
        System.out.println(tp1.getPriority());
        System.out.println(tp2.getPriority());
        System.out.println(tp3.getPriority());
        
        //设置优先级
        tp1.setPriority(10);
        tp2.setPriority(1);
        
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

public class ThreadPriority extends Thread{
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);
        }
        
    }

}

(5)线程的控制(常见方法)
A:休眠线程

//线程睡眠  public static void sleep(long millis)
public class ThreadSleepDemo {
 
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        
        //设置线程名称
        ts1.setName("a");
        ts2.setName("b");
        ts3.setName("c");
        
        //启动线程
        ts1.start();
        ts2.start();
        ts3.start();
        
    }
    
}

public class ThreadSleep extends Thread {

    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x + ",时间:" + new Date());
            //睡眠
            try {
                Thread.sleep(1000);//睡眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
        
    }
}

B:加入线程

//public final void join():等待线程终止
public class ThreadJoinDemo {

    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();
        
        tj1.setName("aa");
        tj2.setName("bb");
        tj3.setName("cc");
        
        tj1.start(); 
        //等待tj1执行完
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        tj2.start();
        tj3.start();
        
    }
}

public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);

        }
    }
}

C:礼让线程

/*
 * public static void yield():暂停当前正在执行的线程，并去执行其他线程
 * 可以让多个线程更加和谐，但是还不能保证完全均匀
 */
public class ThreadYieldDemo {
    public static void main(String[] args) {
        ThreadYield ty1 = new ThreadYield();
        ThreadYield ty2 = new ThreadYield();
        
        ty1.setName("a");
        ty2.setName("b");
        
        ty1.start();
        ty2.start();
    }

}

public class ThreadYield extends Thread{
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);

            Thread.yield();
        }
    }

}

D:后台线程（守护线程）

/*
 * public final void setDaemon(boolean on)
 * 将该线程标记为守护线程或者用户线程
 * 当正在运行的线程都是守护线程时，java虚拟机退出
 * 该方法必须在启动前调用
 */
public class ThreadDaemonDemo {

    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
        
        td1.setName("aa");
        td2.setName("bb");
        
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);
        
        td1.start();
        td2.start();
        
        //设置主类线程名称
        Thread.currentThread().setName("dd");
        for(int x = 0; x < 5; x++){
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }
}

public class ThreadDaemon extends Thread{
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);
        }
    }

}

E:终止线程(掌握)

public class ThreadStopDemo {

    public static void main(String[] args) {
        ThreadStop ts = new ThreadStop();
        
        ts.start();
        
        try {
            Thread.sleep(3000);
            ts.interrupt();
        } catch (InterruptedException e) {
            
            e.printStackTrace();
        }
    }
}

public class ThreadStop extends Thread{
    @Override
    public void run() {
        System.out.println("开始时间：" + new Date());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            
            //e.printStackTrace();
            System.out.println("线程被中断");
        }
        
        System.out.println("结束时间：" + new Date());
    }

}

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

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

//继承Thread类来实现
public class SellTicketDemo {

    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();
    }
}

public class SellTicket extends Thread {

    //定义100张票
    //private int tickets = 100;
    //为了让多个线程对象共享这100张票，将其用静态修饰
    private static int tickets = 100;
    @Override
    public void run() {
        //定义100张票
        //这里每个线程进来都会走这里，相当于每个线程卖自己的100张票，将票数定义到外面
        //int tickets = 100;
        
        //表示电影院一直有票
        while(true){
            if(tickets > 0){
                System.out.println(getName() + "正在出售第：" + (tickets--) + "张票");
            }
        }
    }
}

B:实现Runnable接口（多线程问题一般采用这种方法）

//实现Runnable接口的方法
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();
    }
}

public class SellTicket implements Runnable {
    //定义100张票
    private int tickets = 100;
    
    @Override
    public void run() {
        while(true){
            if(tickets > 0){
                System.out.println(Thread.currentThread()
                        .getName()+ "正在出售第：" + (tickets--) + "张票" );
            }
        }
    }

}

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

   因为CPU的一次操作必须是原子性的
b:负数票

   随机性和延迟性导致

(9)多线程安全问题的原因

(也是以后判断一个程序是否有线程安全问题的依据)
A:是否有多线程环境
B:是否有共享数据
C:是否有多条语句操作共享数据

(10)同步解决线程安全问题
A:同步代码块
synchronized(对象) {
    需要被同步的代码;
}

    注意：同步可以解决安全问题的根本原因在于这个对象上面

               该对象如同锁的功能。多个线程必须是同一把锁。

//实现Runnable接口的方法
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();
    }
}

public class SellTicket implements Runnable {
    //定义100张票
    private int tickets = 100;
    
    //创建锁对象 同一把锁
    private Object obj = new Object();
    
    @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--) + "张票" );
             }
         }
     }
   }
}

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

//实现Runnable接口的方法
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();
    }
}

public class SellTicket implements Runnable {
    //定义100张票
    private int tickets = 100;
    
    //创建锁对象 同一把锁
    //private Object obj = new Object();
    //任意对象
    private Demo d = new Demo();
    @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--) + "张票" );
             }
         }
     }
   }
}

class Demo{
    
}

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

这里的锁对象是this

//实现Runnable接口的方法
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();
    }
}

public class SellTicket implements Runnable {
    //定义100张票
    private int tickets = 100;
    
    //创建锁对象 同一把锁
    //private Object obj = new Object();
    
    //任意对象
    private Demo d = new Demo();
    
    private int x = 0;
    @Override
    public void run() {
        while(true){
            if(x%2 == 0){
                synchronized (this) {
                    if(tickets > 0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread()
                                .getName()+ "正在出售第：" + (tickets--) + "张票" );
                     }
                 }
             
            }else{
                sellTicket();
            }
            x++;
            
     }
  }

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

class Demo{
 }

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

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

//实现Runnable接口的方法
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();
    }
}

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;
    @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{
                sellTicket();
            }
            x++;
            
     }
  }

  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{
 }

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

public class ThreadDemo3 {
public static void main(String[] args) {
    //线程安全的类
    StringBuffer sb = new StringBuffer();
    Vector<String> v = new Vector<String>();
    Hashtable<String, String> hsah = new Hashtable<String, String>();
    
    //Vector是线程安全的时候考虑使用。但即使安全也不会考虑使用
    //用下面这种安全的
    List<String> list1 = new ArrayList<String>();//线程不安全
    //线程安全
    List<String> list2 = Collections.synchronizedList(new ArrayList<String>());
 }
}