黑马程序员——多线程篇

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

   进程：正在执行的程序。

   线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景)，进程中至少有一个线程。

   对于JVM，启动时，只好有两个线程：jvm的主线程。jvm的垃圾回收线程。

如何在程序中自定义线程呢？

   Java给我们提供了对象线程这类事物的描述。该类是Thread。该类中定义了，创建线程对象的方法(构造函数)，提供了要被线程执行的代码存储的位置（run()）；还定义了开启线程运行的方法(start()).同时还有一些其他的方法用于操作线程：static Thread currentThead()；String getName()；static void sleep(time)throws InterruptedException；要运行的代码都是后期定义的。

   创建线程的第一种方式是：继承Thread类。原因：要覆盖run方法，定义线程要运行的代码。

   步骤：

       1，继承Thread类。

       2，覆盖run方法。将线程要运行的代码定义其中。

       3，创建Thread类的子类对象，其实就是在创建线程，调用start方法。

   创建线程的第二种方式：实现Runnable接口。

   步骤：

       1，定义了实现Runnable接口。

       2，覆盖接口的run方法。将多线程要运行的代码存入其中。

       3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。

           为什么要传递？因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象传递给Thread。让Thread线程去使用该对象调用其run方法。

       4，调用Thread对象的start方法。开启线程。

   两种方式的特点：

       实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。

   线程状态：

       被创建：start()

       运行：具备执行资格，同时具备执行权；

       冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

       临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

       消亡：stop()

   多线程具备随机性。因为是由cpu不断的快速切换造成的。就有可能会产生多线程的安全问题。

   问题的产生的原因：

   几个关键点：

       1，多线程代码中有操作共享数据。

       2，多条语句操作该共享数据。

   当具备两个关键点时，有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始参与执行。就会发生数据错误。

   解决方法：

   当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。

同步

   同步的原理：就是将部分操作功能数据的代码进行加锁。

   同步的表现形式：

   1，同步代码块。

   2，同步函数。

   两者有什么不同：

       同步代码块使用的锁是任意对象。

       同步函数使用的锁是this。

   注意：对于static的同步函数，使用的锁不是this。是 类名.class 是该类的字节码文件对象。

   同步的好处：解决了线程的安全问题。

         弊端：较为消耗资源。同步嵌套后，容易死锁。

   要记住：同步使用的前提：

       1，必须是两个或者两个以上的线程。

       2，必须是多个线程使用同一个锁。

       这是才可以称为这些线程被同步了。

死锁代码：

class Test implements Runnable
{
    private boolean flag;//定义标记，用于调节两个线程的运行。
    Test(boolean flag)
    {
        this.flag = flag;
    }
    public void run()
    {
        if (flag)
        {
            while (true)
            {          
                synchronized(MyLock.locka)
                {
                    System.out.println("if locka");//线程t1需要MyLock.lockb，但是else的MyLock.lockb内有t2。
                    synchronized(MyLock.lockb)
                    {
                        System.out.println("if lockb");
                    }
                }
            }
        }
        else
        {
            while (true)
            {          
                synchronized(MyLock.lockb)
                {
                    System.out.println("else lockb");//线程t2需要MyLock.locka，但是if的MyLock.locka内有t1。
                    synchronized(MyLock.locka)
                    {
                        System.out.println("else locka");
                    }
                }
            }
        }
    }
}
class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object();
}
class DeadLockTest
{
    public static void main(String[] args)
    {
        //该线程运行if语句。
        Thread t1 = new Thread(new Test(true));
                                      
        //该线程运行else语句。
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}

   java.lang.Thread 的方法

       interrupt()：中断线程。

       setPriority(int newPriority)：更改线程的优先级。

       getPriority()：返回线程的优先级。

       toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

       Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

       setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

       join：临时加入一个线程的时候可以使用join方法。当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

JKD1.5中提供了多线程升级解决方案。

将同步synchronized替换成显式的Lock操作。

将Object中的wait，notify，notifyAll，替换了Condition对象。该对象可以Lock锁获取。

在该示例中，实现了本方只唤醒对方的操作。

class Test implements Runnable
{
    private boolean flag;//定义标记，用于调节两个线程的运行。
    Test(boolean flag)
    {
        this.flag = flag;
    }
    public void run()
    {
        if (flag)
        {
            while (true)
            {          
                synchronized(MyLock.locka)
                {
                    System.out.println("if locka");//线程t1需要MyLock.lockb，但是else的MyLock.lockb内有t2。
                    synchronized(MyLock.lockb)
                    {
                        System.out.println("if lockb");
                    }
                }
            }
        }
        else
        {
            while (true)
            {          
                synchronized(MyLock.lockb)
                {
                    System.out.println("else lockb");//线程t2需要MyLock.locka，但是if的MyLock.locka内有t1。
                    synchronized(MyLock.locka)
                    {
                        System.out.println("else locka");
                    }
                }
            }
        }
    }
}
class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object();
}
class DeadLockTest
{
    public static void main(String[] args)
    {
        //该线程运行if语句。
        Thread t1 = new Thread(new Test(true));
          
        //该线程运行else语句。
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}