线程

如何证明多线程?

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

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();
    }
        
        

}

 

 

 

posted @ 2017-10-05 20:56  S-Mustard  阅读(247)  评论(0编辑  收藏  举报