java多线程

 一个线程是进程中的执行流程，一个进程可以同时包括多个线程，每个线程可以得到一段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位）

线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

2、实现线程的两种方式

2.1、继承Thread类

Thread类是java.lang包中的一个类。

通过该方法实现进程有三个步骤

1）继承Thread类

2）实现run()方法

3）调用start()方法

package com.pjf.thread;

//继承Thread类
public class ThreadTest extends Thread {

    private int count = 10;

    // 重写run()方法
    public void run() {
        while (true) {
            System.out.println(count + " ");
            if (--count == 0) {
                return;
            }
        }
    }

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        // 调用start()方法
        threadTest.start();
    }
}

2.2、实现runnable接口

通过该方法实现进程有四个步骤

1）实现Runnable接口

2）重写run方法

3）通过public Thread(Runnable r)构造方法来创建进程

4）调用start()方法

package com.pjf.runnable;

//实现Runnable接口
public class RunnableTest implements Runnable {

    private int count = 10;

    // 重写run方法
    public void run() {
        while (true) {
            System.out.println(count + " ");
            if (--count == 0)
                return;
        }
    }

    public static void main(String[] args) {
        // 通过public Thread(Runnable r)构造方法来创建进程
        RunnableTest runnableTest = new RunnableTest();
        Thread thread = new Thread(runnableTest);
        // 调用start方法
        thread.start();
    }
}

3、线程的生命周期

线程具有生命周期，包括七个状态，分别为初始状态、就绪状态、运行状态、锁池状态、等待状态、阻塞状态、死亡状态。

初始状态：创建了一个进程对象。

就绪状态：调用了该对象的start()方法。等待获取CPU的使用权就可以运行。

运行状态：获取了CPU，执行程序代码

锁池状态：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

等待状态：调用对象的wait方法，进入等待状态，并释放进程锁。

阻塞状态：调用对象的sleep或join方法，进入休眠状态，休眠结束后，转入就绪状态，等待获取cpu

死亡状态：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

4、函数说明

sleep();

yeild();

join();

synchronized；

wait()；

notify();

notifyAll();

4.1、sleep() 在指定的毫秒数内让当前正在执行的线程休眠

package com.pjf.runnable;

public class RunnableTest implements Runnable {

    private int count = 10;

    public void run() {
        while (true) {
            System.out.println(count + " ");
            count--;
            try {
                // 线程休眠
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 0)
                return;
        }
    }
    public static void main(String[] args) {
        RunnableTest runnableTest = new RunnableTest();
        Thread thread = new Thread(runnableTest);
        thread.start();
    }
}

4.2、yeild()让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会

package com.pjf.runnable;

public class RunnableTestYeild implements Runnable {

    private int count = 10;

    public void run() {
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 50000000; i++) {
            count = count + (i + 1);
            Thread.yield();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("用时：" + (endTime - beginTime) + " 毫秒！");
    }

    public static void main(String[] args) {
        RunnableTestYeild runnableTest = new RunnableTestYeild();
        Thread thread = new Thread(runnableTest);
        thread.start();
    }
}

4.3、join()主线程等待子线程的终止后才能继续执行

 泡茶前必须洗茶杯、烧开水，即使泡茶本身的动作的时间短于烧开水的时间，通过join()实现

package com.pjf.join;

public class Water extends Thread {

    public void run() {
    System.out.println("开始烧开水");
    try {        
        Thread.currentThread().sleep(1000);        
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("结束烧开水");
    }    
}

package com.pjf.join;

public class WashTeaCup extends Thread {
    
    public void run() {
        System.out.println("开始洗茶杯");
        for(int i=0;i<5;i++){
            System.out.println("开始洗第"+i+"个茶杯");
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("结束洗第"+i+"个茶杯");
        }
    }
}

package com.pjf.join;

public class MakeTea extends Thread {
    private WashTeaCup washTeaCup;
    private Water water;

    public MakeTea(WashTeaCup washTeaCup, Water water) {
        this.washTeaCup = washTeaCup;
        this.water = water;
    }

    public void run() {
        System.out.println("开始泡茶");
        try {
            washTeaCup.join();
            water.join();
            Thread.currentThread().sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("泡茶结束");
    }

    public static void main(String[] args) throws InterruptedException {
        WashTeaCup washTeaCup = new WashTeaCup();
        Water water = new Water();
        MakeTea makeTea = new MakeTea(washTeaCup, water);
        
        makeTea.start();
        water.start();
        washTeaCup.start();
    }
}

4.4、synchronized同步和死锁

参考http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html，考虑了四种情况，讲解清晰

public class ThreadTest
{
    public static void main(String[] args)
    {
        Example example = new Example();

        Thread t1 = new Thread1(example);
        Thread t2 = new Thread1(example);

        t1.start();
        t2.start();
    }

}

class Example
{
    public synchronized void execute()
    {
        for (int i = 0; i < 10; ++i)
        {
            try
            {
                Thread.sleep(500);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }

}

class Thread1 extends Thread
{
    private Example example;

    public Thread1(Example example)
    {
        this.example = example;
    }

    @Override
    public void run()
    {
        example.execute();
    }

}

如果不加synchronized关键字，则两个线程同时执行execute()方法，输出是两组并发的。

如果加上synchronized关键字，则会先输出一组0到9，然后再输出下一组，说明两个线程是顺次执行的。

4.5、wait()、notify()

参考http://www.cnblogs.com/mengdd/archive/2013/02/20/2917956.html

wait()方法使得当前线程必须要等待并释放所有锁，等到另外一个线程调用notify()或者notifyAll()方法。

notify()方法会唤醒一个等待当前对象的锁的线程。如果多个线程在等待，它们中的一个将会选择被唤醒。这种选择是随意的，和具体实现有关。（线程等待一个对象的锁是由于调用了wait方法中的一个）

实例：利用两个线程，对一个整形成员变量进行变化，一个对其增加，一个对其减少，利用线程间的通信，实现该整形变量0101这样交替的变更。

NumberTest

public class NumberHolder
{
    private int number;

    public synchronized void increase()
    {
        if (0 != number)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        // 能执行到这里说明已经被唤醒
        // 并且number为0
        number++;
        System.out.println(number);

        // 通知在等待的线程
        notify();
    }

    public synchronized void decrease()
    {
        if (0 == number)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

        }

        // 能执行到这里说明已经被唤醒
        // 并且number不为0
        number--;
        System.out.println(number);
        notify();
    }

}



public class IncreaseThread extends Thread
{
    private NumberHolder numberHolder;

    public IncreaseThread(NumberHolder numberHolder)
    {
        this.numberHolder = numberHolder;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 20; ++i)
        {
            // 进行一定的延时
            try
            {
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            // 进行增加操作
            numberHolder.increase();
        }
    }

}



public class DecreaseThread extends Thread
{
    private NumberHolder numberHolder;

    public DecreaseThread(NumberHolder numberHolder)
    {
        this.numberHolder = numberHolder;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 20; ++i)
        {
            // 进行一定的延时
            try
            {
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            // 进行减少操作
            numberHolder.decrease();
        }
    }

}



public class NumberTest
{
    public static void main(String[] args)
    {
        NumberHolder numberHolder = new NumberHolder();
        
        Thread t1 = new IncreaseThread(numberHolder);
        Thread t2 = new DecreaseThread(numberHolder);
                
        t1.start();
        t2.start();
    }

}