Java多线程

package j2se.classes;
/*线程的用处：解决了并发问题，也就是对象需要同时运行时，就可以用多线程技术
 * 
 * 线程--如何使用
 * java中一个类要当做线程来使用有两个方法
 * 1.集成Thread类，并重写run函数
 * 2.实现Runnable接口，并重写run函数
 * 
 * 因为java是单继承的，在某些情况下一个类可能已经继承了某个弗雷，这时在用继承Thread类方法来创建线程显然不可能，
 * java设计者提供了另外一个方式来创建线程，就是通过实现Runnable接口来创建线程
 * 
 * 线程--继承Thread和实现Runnable的区别
 * 从java的设计来看，通过继承Thread或者实现Runnable的接口来创建线程本质上没有区别，
 * 从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口，如果一定要说区别，有几点：
 *  1.尽可能的实现Runnable接口的方式来创建线程
 *  2.在使用Thread的时候一定要new一个实例出来，调用start()方法即可启动一个线程
 *  Thread test = new Thread();
 *  test.start();
 *  
 *  3.在使用Runnable的时候需要先new一个实现Runnable的实例，之后用Thread调用如
 *  Test t = new Test();
 *  Thread test = new Thread(t);
 *  test.start();
 *  
 * 用实现Runnable接口的特点
 * 1.用实现Runnable接口的方法创建对象可以避免java单继承机制带来的局限
 * 2.用实现Runnable接口的方法，可以实现多个线程共享同一段代码（数据）
 * 因此如果程序有同步逻辑需求，则使用Runnable的方法来创建线程
 * 
 * 线程--深入理解
 * 不管是通过继承Thread，还是通过实现Runnable接口创建线程，他们的一个对象只能启动（即start()）一次，否则就会有异常抛出
 * 
 */

线程--概念
     线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。

线程
1、线程是轻量级的进程
2、线程没有独立的地址空间(内存空间)
3、线程是由进程创建的(寄生在进程)
4、一个进程可以拥有多个线程-->这就是我们常说的多线程编程
5、线程有几种状态：
   a、新建状态(new)
   b、就绪状态(Runnable)
   c、运行状态(Running)
   d、阻塞状态(Blocked)
   e、死亡状态(Dead)

/**
 * 继承Thread类实现线程
 * 或者实现Runnable接口
 */
class Cat extends Thread {
    //计数
    int times = 0;
    public void run() {
        //休眠一秒，1000ms = 1s
        //sleep()进入Block状态，并释放资源
        while(true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace(); //打印异常的堆栈信息，指明错误原因
            }

            times++;
            System.out.println("Hello word");
            if(times == 10) {
                break;
            }
        }
    }
}

class Dog implements Runnable {
    int times = 0;
    //重写run函数
    public void run() {
        while(true) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }

            times++;
            System.out.println("hahhahaha" + times);
            if (times == 10) {
                break;
            }
        }
    }
}
public class Thread1 {  
    public static void main(String[] args) {
        Cat cat = new Cat(); //创建对象
        cat.start();     //启动线程，调用run方法

        Dog dog = new Dog();
        //创建线程
        Thread t = new Thread(dog);
        //启动线程
        t.start();
    }
}

/* java线程的同步
 * 线程同步机制--介绍
 * 多线程变成为我们处理同时并发的事务提供了很好的帮助，但是由此而来引发一个严重的问题，那就是线程的安全问题
 * 而解决这个问题的关键，是保证事物的原子性（线程1开始执行某段原子代码，线程2要执行这段代码，必须等待线程1执行完之后，才能执行）
 * java处理事物原子性的方法非常简单，只需要在需要保证原子性的代码块如下代码 
 * synchronized(Object) {
 *   <span style="white-space:pre"> </span>代码块
 * }
 * 这就是java的同步机制*/
public class Thread3 {
    public static void main(String[] args) {
        TicketWindow tw1 = new TicketWindow();  //定义售票窗口        
        Thread t1 = new Thread(tw1);//创建线程
        Thread t2 = new Thread(tw1);
        Thread t3 = new Thread(tw1);            
        t1.start();//启动线程
        t2.start();
        t2.start();     
    }
}
class TicketWindow  implements Runnable{    //售票窗口
    private int nums = 2000;    
    public void run() {
        while(true) {
            //同步代码块
            synchronized(this) {
                if(nums > 0) { //判断是否有票
                    //显示售票信息，currentThread().getName()获取当前线程名字
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + nums + "票");

                try{
                    Thread.sleep(1000);
                }catch (Exception e) {
                    e.printStackTrace();
                }
                nums--;
            }else {
            break;  //票已卖完
             }