多线程

1、调用Thread类可以操作线程。步骤是：调用thread类创建线程，复写run();方法，启动线程(调用run方法)。每次的结果都不同是因为CUP的使用权不确定。thread类中的run方法是用于存储线程的代码，同理，main方法是虚拟机要调用的代码的存储位置。run();和start();的区别是前者是创建新线程，后者仍旧是单线程。一个thread线程子类可以创建多个线程，多个子类也可以分别创建自己的子线程。

package pack;

public class Test1
{
    public static void main(String[] args) 
    {
        Thread1 t=new Thread1();
        t.start();   //开启Thread1线程
        Thread1 tt=new Thread1();
        tt.start();
        
        Thread2 t1=new Thread2();
        t1.run();    //未开启Thread2线程，只是简单地调用，仍旧是单线程
        
        for(long i=0;i<10;i++)
            System.out.println("主线程："+i);
        
        Thread t2=new Thread();
        t2.start();
    }
}
class Thread1 extends Thread
{
    public void run()  //一个存储线程的空间
    {
        for(long i=0;i<10;i++)
            System.out.println("自定义线程1："+i);
    }
}
class Thread2 extends Thread
{
    public void run()
    {
        for(long i=0;i<10;i++)
            System.out.println("自定义线程2："+i);
    }
}

2、线程分为5种状态：创建，运行，冻结，消亡和临时状态。其中，运行状态是具备有运行资格也有执行权的状态，冻结状态是放弃了执行资格，临时状态(阻塞状态)是具有运行资格但没有执行权，消亡状态是没有了运行资格程序结束。Thread类创建了线程对象是线程创建状态，用new关键字来实现；线程对象调用start方法后处于运行状态；运行状态的线程通过sleep(time)方法和wait方法放弃运行资格，时间到了或者用notify方法唤醒线程，使线程进入临时状态；临时状态都的线程具备有运行资格，临时状态和运行状态可以相互转化；运行态的线程也可以用stop方法或者因为run内的程序结束而进入消亡状态。

3、每一个线程都有自己的默认名称：Thread-编号，编号从0开始。currentThread()方法是获取当前线程对象。setName()是设置线程名称，getName();是获取线程名称。

4、Java还可以用runnable来定义线程。步骤是：定义一个runnable接口的子类，重写子类的run方法，创建一个thread类的子类，将runnable的子类对象作为实际参数传入thread子类中，调用Thread子类的start方法创建线程，执行run方法内的线程。

5、执行接口的类方法不能抛出异常，一般在方法内部用catch解决，如果要抛出就需要在定义接口的时候抛出异常。多线程安全问题产生的原因会是一个共享的数据被多个线程操作产生的错误。解决的一般办法是让一个线程执行完在执行另一个线程。java提供了专业的同步代码块来解决这个问题。synchronizedi(对象){要同步的代码块}。多个线程需要判断锁，比较消耗资源。同步的另一种方法是将同步修饰符synchronized放在函数上，形成同步函数。

package pack;

public class Test1
{
    public static void main(String[] args) 
    {
        Thread1 t=new Thread1();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();
        t3.start()  ;
    }
}
class Thread1 implements Runnable 
{
    private int tt=100;
    /*
    Object o=new Object();
    public void run()
    {
        while(true)
        {
            synchronized(o)
            {
                if(tt>0)
                {
                    try{Thread.sleep(10);}catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"  "+tt--);
                }
            }
        }
    }
    */
    public synchronized void run()
    {
        while(true)
        {
                if(tt>0)
                {
                    try{Thread.sleep(10);}catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"  "+tt);
                    tt--;
                }
        }
    }
}
　　说明：此程序虽然使用了同步修饰符synchronized，但它不是多线程。

6、同步函数的锁是this。如果同步函数被静态修饰后，锁不能是this了，因为静态中不能用this，静态同步函数的锁是该方法锁在类的字节码文件：类名.class。

package pack;
/*
 * 总共有5000张票，设置三个窗口，也即三个线程，售票。
 */
public class Test1
{
    public static void main(String[] args) 
    {
        Thread1 t=new Thread1();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
    }
}
class Thread1 implements Runnable 
{
    private int tt=5000;
    /*
     * private static int tt=5000;      //静态同步函数的锁是类class
    //Object o=new Object();
    public void run()
    {
        while(true)
        {
            synchronized(Thread1.class)
            {
                if(tt>0)
                {
                    try{Thread.sleep(10);}catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"  "+tt--);
                }
            }
        }
    }
    */
    public void run()
    {
        while(true)
        {
            this.show();    //同步函数的锁是this
        }
    }
    public synchronized void show()  //单独把if语句拿出来，构造同步函数
    {
        if(tt>0)
        {
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"  "+tt--);
        }
    }
}

7、死锁：通常的情况是同步中嵌套同步，而锁却不同。锁可以是任意对象。

package pack;
//create a deadlock programming
public class DeadLock
{
    public static void main(String[] args) 
    {
        Thread t=new Thread(new Test(true));
        Thread t1=new Thread(new Test(false));
        t.start();
        t1.start();
    }
}

class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag=flag;
    }
    @Override
    public void run() 
    {
        // TODO Auto-generated method stub
        if(flag)
        {
            synchronized(Lock.la)
            {
                System.out.println("la lock");
                synchronized(Lock.lb)
                {
                    System.out.println("lb lock");
                }
            }
        }
        else
        {
            synchronized(Lock.lb)
            {
                System.out.println("lb lock");
                synchronized(Lock.la)
                {
                    System.out.println("la lock");
                }
            }
        }
    }
}
class Lock
{
    public static Object la=new Object();
    public static Object lb=new Object();
}

 8、线程间通信：多个线程共同操作一个资源，但操作方式不同。同步考虑多个线程是否是同一个锁，是否多个线程都用同步修饰符。wait,notify,notifyall方法都是只用在同步里，因为要对持有监视器(锁)的线程里操作，只有同步里才有锁。

以下是多线程低版本的jdk下的程序： 

package pack;
//线程间的通信,创建两个线程和一个共享资源。其中一个线程为资源属性赋值，另一个线程输出资源属性值。
public class ThreadCommunication
{
    public static void main(String[] args) 
    {
        Resourse r=new Resourse();
        /*
        Input i=new Input(r);
        Output o=new Output(r);
        Thread t1=new Thread(i);
        Thread t2=new Thread(o);
        t1.start();
        t2.start();
        */
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
    }
}
//多线程通信方法一
/*
//创建一个共享资源，人
class Resourse
{
    String name;
    String sex;
    boolean b=true;
}
//创建一个为资源赋值的线程
class Input implements Runnable
{
    private Resourse r;
    Input(Resourse r)
    {
        this.r=r;
    }
    public void run()
    {
        int x=0;
        while(true)
        {
            synchronized(r) //锁是Resourse类对象
            {
                while(r.b==true)
                {
                    if(x==0)
                    {
                        r.name="Joe";
                        r.sex="man";
                    }
                    else
                    {
                        r.name="Lisa";
                        r.sex="woman";
                    }
                    x=(x+1)%2;  //保证if和else交替执行
                    r.b=false;
                }
            }
        }
    }
}
//创建一个输出资源属性的线程
class Output implements Runnable
{
    private Resourse r;
    Output(Resourse r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)   //保证while内的代码循环执行
        {
            synchronized(r)  //锁是Resourse类对象,和上文是同一个锁，实现同步
            {
                while(r.b==false)
                {
                    System.out.println(r.name+"  "+r.sex);
                    r.b=true;
                }
            }
        }
    }
}
*/
//多线程通信方法二
/*
//创建一个共享资源，人
class Resourse
{
    String name;
    String sex;
    boolean b=true;
}
//创建一个为资源赋值的线程
class Input implements Runnable
{
    private Resourse r;
    Input(Resourse r)
    {
        this.r=r;
    }
    public void run()
    {
        int x=0;
        while(true)
        {
            synchronized(r) //锁是Resourse类对象
            {
                if(!r.b)     //进行线程停止等待，如果r.b为真则执行if语句内的程序
                    try{r.wait();}catch(Exception e){}
                if(x==0)
                {
                    r.name="Joe";
                    r.sex="man";
                }
                else
                {
                    r.name="Lisa";
                    r.sex="woman";
                }
                x=(x+1)%2;  //保证if和else交替执行
                r.b=false;
                r.notify();  //线程的锁需要标识
            }
        }
    }
}
//创建一个输出资源属性的线程
class Output implements Runnable
{
    private Resourse r;
    Output(Resourse r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)   //保证while内的代码循环执行
        {
            synchronized(r)  //锁是Resourse类对象,和上文是同一个锁，实现同步
            {
                if(r.b)   //线程停止等待
                    try{r.wait();}catch(Exception e){}
                System.out.println(r.name+"  "+r.sex);
                r.b=true;
                r.notify();
            }
        }
    }
}
*/
//多线程通信代码优化
//创建一个共享资源，人
class Resourse
{
    private String name;
    private String sex;
    boolean circle=true;
    public synchronized void setNameSex(String name,String sex)
    {
        if(!this.circle)
            try{wait();}catch(Exception e){}
        this.name=name;
        this.sex=sex;
        circle=false;
        notify();
    }
    public synchronized void out()
    {
        if(this.circle)   //线程停止等待
            try{wait();}catch(Exception e){}
        circle=true;
        notify();
        System.out.println(name+"  "+sex);
    }
}
//创建一个为资源赋值的线程
class Input implements Runnable
{
    private Resourse r;
    Input(Resourse r)
    {
        this.r=r;
    }
    public void run()
    {
        int x=0;
        while(true)
        {
                if(x==0)
                    r.setNameSex("Joe", "man");
                else
                    r.setNameSex("Lisa", "woman");
                x=(x+1)%2;  //保证if和else交替执行
        }
    }
}
//创建一个输出资源属性的线程
class Output implements Runnable
{
    private Resourse r;
    Output(Resourse r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)   //保证while内的代码循环执行
        {
                r.out();
        }
    }
}

9、JDK1.5以上的版本提供了多线程的解决方案，它将同步synchronized替换成了lock操作，将Object中的wait，notify和notifyAll替换成了condition对象，该对象可以以lock锁来获取，condition对象的single可以实现本方唤醒对方的功能。

代码：线程间通信之两个生产者和两个消费者问题，生产者生产的商品全部由消费者消费，是一个平衡问题。

package pack;
import java.util.concurrent.locks.*;
//线程间的通信,两个生产者，两个消费者和一个同种共享商品资源,每个商品都有标号，由count计数。
public class ThreadCommunication
{
    public static void main(String[] args) 
    {
        Shop s=new Shop();
        Producer p=new Producer(s);                      //以构造函数初始化p对象
        Consumer c=new Consumer(s);
        Thread t1=new Thread(p,"生产者1");                    //runnable子类对象作为参数传入Thread构造函数中，实例化t1线程
        Thread t11=new Thread(p,"生产者2");                    //两个生产者对象
        Thread t2=new Thread(c,"消费者1");                    //两个消费者对象
        Thread t22=new Thread(c,"消费者2");
        t1.start();                                        //启动4个线程
        t11.start();
        t2.start();
        t22.start();
    }
}
//定义商品资源
class Shop
{
    private String name;                                         //定义商品名字
    private int count=1;                                         //定义商品编号
    private boolean flag=false;                                    //定义标记，方便循环赋值
    private final Lock lock=new ReentrantLock();                //引用接口Lock，实例化ReentrantLock类
    private Condition condition1=lock.newCondition();            //调用Lock类的newCondition()方法，创建锁
    private Condition condition2=lock.newCondition();
    public void setName(String name) throws InterruptedException //属性构造器，为类属性赋值
    {
        lock.lock();
        try
        {
            while(flag)
                condition1.await();                                //线程停止等待
            this.name=name+"编号："+count++;                        //打印出商品名和商品编号
            System.out.println(Thread.currentThread().getName()+"---"+this.name);//打印生产者进程
            flag=true;
            condition2.signal();                                //唤醒线程
        }
        finally
        {
            lock.unlock();
        }
    }
    public void out() throws InterruptedException
    {
        lock.lock();
        try
        {
            while(!flag)
                condition2.await();
            System.out.println(Thread.currentThread().getName()+"---"+this.name);//打印消费者进程
            flag=false;
            condition1.signal();
        }
        finally                                                    //关闭锁是必须执行的部分
        {
            lock.unlock();
        }
    }
}
//定义生产者,生产者为Shop类对象赋值
class Producer implements Runnable
{
    private Shop s=new Shop();                                    //实例化Shop类对象s
    Producer(Shop s)                                            //用Shop类对象作为参数传递给构造函数
    {
        this.s=s;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                s.setName("商品");
            }
            catch(InterruptedException e)
            {}
        }
    }
}
//定义消费者
class Consumer implements Runnable
{
    private Shop s=new Shop();
    Consumer(Shop s)
    {
        this.s=s;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                s.out();
            }
            catch(InterruptedException e)
            {}
        }
    }
}

10、stop和suspend方法已经过时，让线程结束就是让run方法结束。开启多线程，run方法内的结构一般是循环结构，控制住循环，线程则结束。线程都进入冻结状态，线程就无法停止了，此时需要强制清楚冻结状态，进入运行状态，使用interrupt();方法。

11、所有的前台线程都结束后，后台线程才可以结束。主线程是前台线程。后台线程就是守护线程。

12、线程.join()；方法时要求CPU的执行权。此函数的特点是：当A线程执行到了B线程的join方法时，A线程就会等待，直到执行完，A才会执行。join可以临时加入线程执行，抢占CPU执行资格。

13、线程组：谁开启了线程组(比如main)，谁就是那个组的组名。所有的线程的优先级的默认值都是5。

14、多线程计数，计算运行时间。

package pack;
import java.util.concurrent.CountDownLatch; 
public class Test
{
    public static void main(String[] args) 
    {
        long start=System.currentTimeMillis();
        final CountDownLatch l=new CountDownLatch(3);  //使三个线程在完成操作之前一直等待
        //匿名内部类可以实现一个线程，作为一个小技巧提高程序运行效率
        new Thread()
        {
            public void run()
            {
                for(int i=0;i<30000;i++)
                {
                    System.out.println(Thread.currentThread().getName()+"---"+i);
                }
                l.countDown();
            }
        }.start();
        
        //另一个匿名内部类
        Runnable r=new Runnable()
        {
            public void run()
            {
                for(int i=0;i<30000;i++)
                {
                    System.out.println(Thread.currentThread().getName()+"---"+i);
                }
                l.countDown();
            }
        };
        new Thread(r).start();
                
        //主线程的代码
        
        for(int i=0;i<30000;i++)
        {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
        l.countDown();
        
        try
        {
            l.await();  //当前线程(主线程)在倒计数至零之前一直在等待
        }
        catch(InterruptedException e)
        {
            e.toString();
        }
        long end=System.currentTimeMillis();
        System.out.println("运行的时间是："+(end-start)/1000.0+"秒");
        
    }
}

 以上代码均来自于毕老师的指导。