线程笔记（二）

Thread的常用方法：
* 1.start()：启动线程并执行相应的run()方法
* 2.run():子线程要执行的代码放入run()方法中
* 3.currentThread()：静态的，调取当前的线程
* 4.getName():获取此线程的名字
* 5.setName():设置此线程的名字
* 6.yield():调用此方法的线程释放当前CPU的执行权
* 7.join():在A线程中调用B线程的join()方法，表示：当执行到此方法，A线程停止执行，直至B线程执行完毕， A线程再接着join()之后的代码执行
* 8.isAlive():判断当前线程是否还存活
* 9.sleep(long l):显式的让当前线程睡眠l毫秒
* //调用方式：在线程里面 Thread.sleep(1000)； 线程睡眠一秒
*
* 10.线程通信：wait() notify() notifyAll()
* //线程通信。如下的三个关键字使用的话，都得在同步代码块或同步方法中。
* //wait():一旦一个线程执行到wait()，就释放当前的锁。
* //notify()/notifyAll():唤醒wait的一个或所有的线程
*
* 设置线程的优先级
* getPriority() ：返回线程优先值
* setPriority(int newPriority) ：改变线程的优先级

---

====================================

/*
* 线程的安全问题：打印结果时，会出现重复、错误结果（如：打印数字的线程会出现重复数、错误的数字、范围外的数字）
* 1.线程安全问题存在的原因？
*   由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
*   
* 2.如何来解决线程的安全问题？
*    必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
* 
* 3.java如何实现线程的安全：线程的同步机制
*       
*       方式一：同步代码块
*       synchronized(同步监视器){
*           //需要被同步的代码块（即为操作共享数据的代码）
*       }
*       1.共享数据：多个线程共同操作的同一个数据(变量)
*       2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁
*       要求：所有的线程必须共用同一把锁！
*       注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!
* 
*       方式二：同步方法
*       将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行
*       此方法时，其它线程在外等待直至此线程执行完此方法。
*       >同步方法的锁：this
* 
* 4.线程的同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。
* 
*/

public class thread4 {

    public static void main(String[] args) {
        ////////////////////////////////////////
        //同步方法
        MyThread4_1 w = new MyThread4_1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");

        t1.start();
        t2.start();
        t3.start();
        ////////////////////////////////////////
        ////////////////////////////////////////        
        //同步代码块
        /*
        MyThread4_2 t4 = new MyThread4_2();
        MyThread4_2 t5 = new MyThread4_2();
        MyThread4_2 t6 = new MyThread4_2();

        t4.setName("线程4");
        t5.setName("线程5");
        t6.setName("线程6");

        t4.start();
        t5.start();
        t6.start();
        */
        ////////////////////////////////////////
    }

}

//同步方法
class MyThread4_1 implements Runnable {
    int index4_1 = 100;// 共享数据

    public void run() {
        while (true) {
            show();
        }
    }

    public synchronized void show() {
        notify();
        if (index4_1 > 0) {
            try {
                Thread.currentThread().sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "同步方法-号码为：" + index4_1--);
        }
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//同步代码块
class MyThread4_2 extends Thread {
    static int index4_2 = 100;// 共享数据
    static Object obj = new Object();

    public void run() {
        while (true) {
            // synchronized (this) {//在本问题中，this表示：w1,w2,w3
            synchronized (obj) {

                obj.notify();

                if (index4_2 > 0) {
                    try {
                        Thread.currentThread().sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "同步代码块-号码为：" + index4_2--);
                }

                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }
    }

}

1、使用线程同步之后，就不会出现重复或者错数的情况了，而且出来的数字结果都变成按顺序了。
2、线程同步这一块重点在于synchronized出现的位置，出现在方法名的前面的时候，就是同步方法。出现在run()方法的里面就是同步代码块，很好认的。
3、还有一个 运行上面代码的时候，main方法里面同步代码块或者同步方法的调用，注释掉其中一个 不然效果不好看出来。
4、notify()/notifyAll()、wait()这些方法要写在同步方法或者同步代码块内
格式是：先写notify(); 在写要运行的方法 method(); 最后写wait();
原因：先让第一个运行的线程执行notify()握着锁，让他走一次这个method方法，然后在执行wait()，让当前的线程释放当前的锁，等下一个线程运行时，新的线程执行notify()后，锁就会被新线程握着，这样就能防止其他线程进来抢资源了。