java之Thread

     * 线程：程序执行的一条路径，一个进程可以包含多条线程
     * 多线程并发执行可以提高程序的效率，可以同时完成多个工作
     *
     * JVM的启动至少启动了垃圾回收线程和主线程两个线程，所以是多线程；
     *
     * 多线程的实现方式有2中：
     *    1. 继承Thread
     *      1) 定义类继承Thread
     *      2) 重写run方法
     *      3) 把新线程要做的事写在run方法中
     *      4) 创建线程对象
     *      5) 开启新线程，内部会自动执行run方法

创建线程的第一种方式：继承Thread类

public static void main(String[] args) {

        MyThread mt = new MyThread();   // 4) 创建线程对象
        mt.start();                     // 5) 开启新线程，内部会自动执行run方法
        for(int i = 0; i < 3000; i++) {
            System.out.println("bb");
        }
    }

}

class MyThread extends Thread {     // 1) 定义类继承Thread
    public void run() {             // 2) 重写run方法
        for(int i = 0; i < 3000; i++) {     // 3) 把新线程要做的事写在run方法中
            System.out.println("aaaaaaaaaaaaaaaa");
        }
    }
}

创建线程的第2中方式：实现Runnable接口     * 实现多线程的第2中方式，实现Runnable接口：
     *       1. 创建类实现Runnable接口
     *    2. 重写run方法，将要执行的代码写入run方法中
     *    3. 创建自定义类的对象
     *    4. 创建Thread类对象，将自定义对象传入
     *    5. Thread类对象调用start方法开启新线程，内部会自动调用Runnnable中的run方法

    public static void main(String[] args) {

        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
        for(int i = 0; i < 3000; i++) {
            System.out.println("bbb");
        }
    }

}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i < 3000; i++) {
            System.out.println("aaaaaaaaaaaa");
        }
    }
    
}

 两种方式的区别：
     *    1. 查看源码的区别
     *        a. 继承Thread:由于子类重写了Thread类的run()，当调用start()方法时，直接找子类的run()方法
     *      b. 实现Runnable：构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断成员变量Runnabe的引用是否为空，
     *         如果不为空，编译时看的是Runnable的run()，运行时执行的是子类的run()方法
     *         
     *    2. 实现使用上的区别：
     *      继承Thread:
     *         a.好处：可以直接使用Thread类中的方法，代码简单
     *         b.弊端：如果已经有了父类，就不能使用这种方法
     *      实现Runnable接口
     *         a.好处：即使自己定义的线程类有了父类也没有关系，因为有了父类可以实现接口，而且接口是可以多实现的
     *         b.弊端：不能直接使用Thread中的方法，需要先获取到线程对象后，才能得到Thread的方法，代码复杂  

使用匿名内部类实现多线程的两种方式:

public static void main(String[] args) {

        new Thread() {
            public void run() {
                for(int i = 0; i < 3000; i++) {
                    System.out.println("aaaaa");
                }
            }
        }.start();
        
        new Thread(new Runnable() {
            public void run() {
                for(int i = 0; i < 3000; i++) {
                    System.out.println("bb");
                }
            }
        }).start();
    }

给线程设置名称两种方式:

      1.  使用构造方法

      2.  使用setName()方法

public class Demo4_ThreadMethod {

    /*
     * 设置线程名字的两种方法：
     *    1. 构造方法
     *    2. setName()方式
     */
    public static void main(String[] args) {

        //demo1();
        //demo2();
        //demo3();
        Thread t = new Thread() {
            public void run() {
                System.out.println(this.getName() + "...ccc");
            }
        };
        t.setName("王五");
        t.start();
    }

    /**
     * 通过setName()方法给线程名赋值
     */
    public static void demo3() {
        new Thread() {
            public void run() {
                this.setName("李四");
                System.out.println(this.getName() + "...bb");
            }
        }.start();
    }

    /**
     * 通过构造方法给线程名称赋值
     */
    public static void demo2() {
        new Thread("张三") {
            public void run() {
                System.out.println(this.getName() + "...aaa");
            }
        }.start();
    }

    /**
     * 线程的名称是默认从0  Thread-0  依次往后累加
     */
    public static void demo1() {
        new Thread() {
            public void run() {
                System.out.println(this.getName() + "...aaa");  //Thread-0...aaa   
            }
        }.start();
    }

}

currentThread()方法和sleep()方法的使用：

public class Demo5_CurrentThread {

    /*
     * CurrentThread()方法用来获取当前正在执行的线程
     * 
     * sleep()方法：会使线程暂时停一段时间
     */
    public static void main(String[] args) {

        new Thread() {
            public void run() {
                System.out.println(getName() + "...bbb");
            }
        }.start();
        
        new Thread(new Runnable() {
            public void run() {
                Thread.currentThread().setName("李四");    
                //由于Runnable接口没有setName() 和 getName()方法，所以需要用currentThread()方法获取当前线程
                System.out.println(Thread.currentThread().getName() + "...aaa");
            }
        }).start();
    }

}

守护线程：

public class Demo6_Daemon {

    /*
     * 守护线程
     */
    public static void main(String[] args) {

        Thread t1 = new Thread() {
            public void run() {
                for(int i = 0; i < 2; i++) {
                    System.out.println(getName() + "...aaaa");
                }
            }
        };
        
        Thread t2 = new Thread() {
            public void run() {
                for(int i = 0; i < 50; i++) {
                    System.out.println(getName() + "...bb");
                }
            }
        };
        
        t2.setDaemon(true);    //设置t2为守护线程，当t1结束时t2也会随之结束
        t1.start();
        t2.start();
    }

}

join()方法的使用：

public class Demo7_Join {

    /*
     * join()插队，等另外一个线程执行完毕后，再接着执行
     * join(1)插队1毫秒，1毫秒后两个线程继续交替执行
     */
    public static void main(String[] args) {
        final Thread t1 = new Thread() {
            public void run() {
                for(int i = 0; i < 10; i++) {
                    System.out.println(getName() + "...aaa");
                }
            }
        };
        
        Thread t2 = new Thread() {
            public void run() {
                for(int i = 0; i < 10; i++) {
                    if(i==2) {
                        try {
                            //t1.join();             //匿名内部类要想调用局部变量，需要局部变量声明为final类型的
                            t1.join(1);              //t1加入1毫秒，1毫秒后两个接着交替执行
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(getName() + "...bb");
                }
            }
        };
        t1.start();
        t2.start();
    }
}

同步的使用：

public class Demo8_Sychronized {

    /*
     * 同步代码块中需要传入的锁对象可以是任何对象，但是不能是匿名对象
     * 
     * 静态同步方法中的锁对象是类的字节码对象，如：demo.class
     */
    public static void main(String[] args) {

        Object o = new Object();
        while(true) {
            synchronized(o) {
                System.out.print("t");
                System.out.print("e");
                System.out.print("s");
                System.out.print("t");
                System.out.println();
            }
            
            synchronized(o) {
                System.out.print("a");
                System.out.print("b");
                System.out.print("c");
                System.out.print("d");
                System.out.println();
            }
        }
    }

}

练习：

       4个窗口同时售100张火车票

继承Thread类的方式

public class Demo9_Ticket {

    /*
     * 四个窗口同时卖出100张票
     */
    public static void main(String[] args) {

        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
    }

}

class Ticket extends Thread{
    private static int ticket = 100;
    //private static Object o = new Object();   如果是使用这种成员变量的方式，需要声明为静态变量
    public void run() {
        while(true) {
            synchronized(Ticket.class) {
                if(ticket <= 0) {
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getName() + "...第" + ticket-- + "张票");
            }
        }
    }
}

------------------------------------------

实现Runnable接口的方式：

public class Demo10_Ticket {

    /*
     * 使用实现Runnable接口进行四个窗口同步卖票
     */
    public static void main(String[] args) {

        Ticket1 t = new Ticket1();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        
        /*Ticket1 t1 = new Ticket1();
        Thread t2 = new Thread(t1);
        t2.start();
        t2.start();
        t2.start();
        t2.start();
        一个线程只能启动一次，调用一次start()方法
        */
    }

}

class Ticket1 implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
        while(true) {
            synchronized(this) {
                if(ticket<=0) {
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "...第" + ticket-- + "张票");
            }
        }
    }
    
}