线程

如何证明多线程？

首先我们需要知道可能有哪些线程，哪段代码是属于哪个线程执行，这个区分了才好证明。而且我们证明需要有大量的数据，这样才能体现出效果。

finalize方法的调用可能是垃圾回收器线程来调用的，如果是则运行该代码有两个线程，那么一定会产生两个线程交替运行的结果（多次尝试），如果没有垃圾回收器线程，那么这个方法的调用就得老老实实地按照顺序接受main方法的安排。

public class Test1 {
    public static void main(String[] agrs) {
        
        for(int i=0;i<1000000;i++)    
        new my();
        for(int i=0;i<10000;i++)
            System.out.println("A：我是属于main线程的");
        
    }

}
 class my{

    @Override
    public void finalize()  {
        // TODO Auto-generated method stub
        System.out.println("B:我是属于垃圾回收器线程的");
    }
     
    
}

结果（选取有代表性的一段）：

B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
A：我是属于main线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的
B:我是属于垃圾回收器线程的

线程的理解

先定义一个人，就是你自己，你有1000句话跟三个人说（a，b，c），如果你不支持线程，也就是无法跟一个人说话，还没说完就跟另一个人说的技能，那么你说话的顺序将是一条线，先将对a说的话说完，再将对b说的话说完，然后完成对c说的话。如果你支持多线程，那么跟a说几句话之后，这时候b过来插话，你就停止跟a的交流，去跟b说话，跟b说到一半，a又过来插话，于是完成对a的话，再完成对b的话，最后c因为没有插话，还是按照你自己的定义，最后完成c的话。这就有两个线程，一个是自己原本定义好的，第二个那就跟b说话的线程了。

自己建一个线程，让某些方法不受main线程约束

自己定义的线程就是上面所说的，将跟b的交流定义成一个线程类，允许b插话，如果将跟c的交流也定义成一个线程类，那么c也能插话了，b和c就打破了本有的规则，可以提前跟你说会话。（争着说话一样，插话的交流都是这样。没有确定性）（不过最后a可能很强大，b和c一点话都插不上）

public class Test2 {
    public static void main(String[] agrs) {
        for(int i=0;i<10000;i++)
            System.out.println("A:main");
        Mytest m=new Mytest();
        m.start();
        
    }

}
class Mytest extends Thread{
    public void run() {
        for(int i=0;i<10000;i++) 
            System.out.println("B：我自己的线程，不受main线程约束");
        
    }
}

public class Test2 {
    public static void main(String[] agrs) {
        for(int i=0;i<10000;i++)
            System.out.println("A:main");
        Mytest m=new Mytest();
        new Thread(m).start();
        
    }

}
class Mytest implements Runnable{
    public void run() {
        for(int i=0;i<10000;i++) 
            System.out.println("B：我自己的线程，不受main线程约束");
        
    }
}

线程的方法

String getName()

获取线程名

void setName(String name)

设置线程名

static Thread currentThread()

该方法必须写在线程代码里面，写在别的线程程序里面就是显示别的线程了（主要用于实现runnable接口的那种线程里面）

 static void sleep(long millis)

 你会发现输出的结果是一秒输出一个

public class Test3 {
    public static void main(String[] agrs) throws InterruptedException {
        System.out.println("nihao");
        Thread.sleep(1000);
        System.out.println("nihao");
        Thread.sleep(1000);
        System.out.println("nihao");
        Thread.sleep(1000);
        System.out.println("nihao");
        Thread.sleep(1000);
        System.out.println("nihao");
        Thread.sleep(1000);
        System.out.println("nihao");
        Thread.sleep(1000);
    }

}

给某个线程加这个方法，可以让有这个方法的线程被最后选择。

void setDaemon(boolean on)

设置这个方法的线程的生命受到非守护线程的影响，当非守护线程生命完了之后，守护线程（设置了该方法的线程）就会挂掉。

void join()

调用该方法的线程是插入线程，当别的线程在执行时，插入该方法，那么调用该方法的线程就会先执行完。

void join(long millis)

设置允许进程插队的时间

tatic void yield()

线程让出cpu的方法（还是有不确定性）

void setPriority(int newPriority) 

设置线程优先级

代码的同步

在使用多线程的同时也有弊端，当一个线程还没完成它的整体工作，就调换到另一个线程（比如你在跟a说话的同时，b过来插话，这时候如果b插上话了，而且当跟a正说“从前。。。。。”，一个完整的话还没说完就会让谈话不愉快）我们要做的就是找到属于一个完整的不可分割的代码块，用synchronized方法传入任何对象锁起来。（传入的对象必须是同一个对象）（同步代码块）

还可以用同步方法的方式锁起来。

线程安全问题

当自己只有一句话跟a，b，c，d说时，你请求跟a说话，a说等一分钟后再说，这时候你还有一句话没说出去，请求跟b说话，b又说等一分钟后再说，于是请求跟c说话，跟c说完之后，a和b又跑过来跟自己说话，程序停止，于是你会发现自己明明说只说一句话的，最后说了三句话。跟期望不符合。于是我们要告诉自己，必须等跟a交流完之后再进行别的，这就没有问题了。将执行的代码块锁起来，关键点是多个线程对象必须用同一把锁才有效。

死锁问题

两个线程的代码块都上了锁，而且一个代码块a里面嵌套了另一把锁，但是这个锁的打开需要等待代码块b锁的打开，但是b代码块里面又嵌套了a中使用的锁，就这样我等你，你等我，程序就停在那了。

 线程的通信

当程序有多个线程时，我们一般都很难控制它们谁先执行，谁后执行，怎么样交替执行。于是通信的作用就在于此。

public class Test4 {
    public static void main(String[] agrs) {
        final Mytest1 my=new Mytest1();
        new Thread() {
            public void run() {
                while(true) {
                    try {
                        my.m1();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while(true) {
                    
                        try {
                            my.m2();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    
                }
            }
        }.start();
        
        
        
        
        
    }

}
class Mytest1 {
    
    private int flag=1;
    public void m1() throws InterruptedException {
        
        synchronized(this) {
        if(flag!=1) {
            this.wait();
        }
        System.out.println("B");
        flag=2;
        this.notify();
        }
    }
    public void m2() throws InterruptedException {
        synchronized(this) {
        if(flag!=2) {
            this.wait();
        }
        System.out.println("A");
        flag=1;
        this.notify(); //随机唤醒某个线程
        }
    }
        
        
    

}

可以看到交替运行

三个线程的交替运行

public class Test5 {
    public static void main(String[] agrs) {
        final Mytest5 my=new Mytest5();
        new Thread() {
            public void run() {
                while(true) {
                    try {
                        my.m1();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while(true) {
                    
                        try {
                            my.m2();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while(true) {
                    
                        try {
                            my.m3();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    
                }
            }
        }.start();
        
        
        
        
        
    }

}
class Mytest5 {
    
    private int flag=1;
    public void m1() throws InterruptedException {
        
        synchronized(this) {
        while(flag!=1) {
            this.wait();
        }
        System.out.println("A");
        flag=2;
        this.notifyAll();
        }
    }
    public void m2() throws InterruptedException {
        synchronized(this) {
        while(flag!=2) {
            this.wait();
        }
        System.out.println("B");
        flag=3;
        this.notifyAll();
        }
    }
    public void m3() throws InterruptedException {
        synchronized(this) {
        while(flag!=3) {
            this.wait();
        }
        System.out.println("c");
        flag=1;
        this.notifyAll();
        }
    }
        
        

}

互斥锁和通信

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test6 {
    public static void main(String[] agrs) {
        final Mytest6 my=new Mytest6();
        new Thread() {
            public void run() {
                while(true) {
                    try {
                        my.m1();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while(true) {
                    
                        try {
                            my.m2();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while(true) {
                    
                        try {
                            my.m3();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    
                }
            }
        }.start();
        
        
        
        
        
    }

}
class Mytest6 {
    private ReentrantLock r=new ReentrantLock();
    private Condition c1=r.newCondition();
    private Condition c2=r.newCondition();
    private Condition c3=r.newCondition();
    private int flag=1;
    public void m1() throws InterruptedException {
        
        r.lock();
        if(flag!=1) {
            c1.wait();
        }
        System.out.println("A");
        flag=2;
        c2.signal();
        r.unlock();
    }
    public void m2() throws InterruptedException {
        r.lock();
        if(flag!=2) {
            c2.await();
        }
        System.out.println("B");
        flag=3;
        c3.signal();
        r.unlock();
    }
    public void m3() throws InterruptedException {
        r.lock();
        if(flag!=3) {
            c3.wait();
        }
        System.out.println("c");
        flag=1;
        c1.signal();
        r.unlock();
    }
        
        

}