多线程

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

******** 传统的多线程 *******


 


创建线程的方式：
        在传递给Thread对象的Runnable对象的run方法中编写代码
        Thread子类覆盖run方法编写代码
        总结：由源码可以看到这两种方式都是在调用Thread的run方法。如果Thread的run方法没有被覆盖，并且为Thread对象设置一个Runnable对象，run方法会调用Runnable对象的ruan方法
        如果Thread子类覆盖了run方法，并且传递了一个Runnable对象，结果是调用Runnable对象的run方法（牵涉到：匿名内部类对象的构造方法如何调用父类的非默认构造方法）




线程的三种调用方法：


[java] view plaincopy
//方法一  
                 Thread thread=new Thread(){  
            public void run() {  
                for (int i = 0; i < 20; i++) {  
                    System.out.println("测试线程"+i+Thread.currentThread().getName());  
                    System.out.println(this.getName());//这个也可以，但不建议用  
                }  
            }  
        };  
        thread.start();  
  
        //方法二  
        new Thread(){  
            public void run() {  
                System.out.println("线程第三种创建方法");  
            }  
        }.start();  
          
        //另一种调用线程的方法,经常用这个，更体现面向对象的思想  
        Thread thread3=new Thread(new Runnable() {  
              
            @Override  
            public void run() {  
                for (int i = 0; i < 20; i++) {  
                    System.out.println("测试线程"+i+Thread.currentThread().getName());  
                    //System.out.println(this.getName());//这个已经不能使用了，因为this指向的是Runnable子类  
                }  
                  
            }  
        });  
        thread3.start();  


 


 


********** 定时器 ***********
工具类 quartz


[java] view plaincopy
//一个简单的定时器  
    new Timer().schedule(new TimerTask(){  
  
        @Override  
        public void run() {  
            // TODO Auto-generated method stub  
            System.out.println("定时器内容");  
        }}, 10000,1000);//第一个时间是隔了多长时间执行，第二个时间是第一次执行之后每隔多长时间执行一次  


 


用于产生附加信息：


[java] view plaincopy
while (true) {  
            System.out.println(new Date().getSeconds());  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }         
        }  


 


子母定时器：


[java] view plaincopy
class MyTimerTask extends TimerTask{  
  
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                count=(count+1)%2;  
                System.out.println("子母测试");  
                new Timer().schedule(new MyTimerTask(), 2000+2000*count);  
            }  
        }  
        new Timer().schedule(new MyTimerTask(), 2000);  


 


****** 传统线程的互斥技术 *****


[java] view plaincopy
package TraditionalThread;  
  
public class TraditionalThreadSynchronized {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
/* 
        //final OutPut outPut=new OutPut();//报错，静态方法中不能new内部类的实例化对象 
new Thread(new Runnable() { 
             
            @Override 
            public void run() { 
                // TODO Auto-generated method stub 
                try { 
                    Thread.sleep(10); 
                } catch (InterruptedException e) { 
                    // TODO Auto-generated catch block 
                    e.printStackTrace(); 
                } 
                outPut.output("peerless2012"); 
            } 
        }).start();*/  
          
        new TraditionalThreadSynchronized().init();  
    }  
    private void init() {  
  
        final OutPut outPut=new OutPut();  
        new Thread(new Runnable() {  
              
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                while (true) {  
                    try {  
                        Thread.sleep(10);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                    outPut.output1("peerlesspeerlesspeerless");  
                }  
            }  
        }).start();  
new Thread(new Runnable() {  
              
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                while (true) {  
                    try {  
                        Thread.sleep(10);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                    outPut.output2("64396732034832038732047083437258340");  
                }  
            }  
        }).start();  
    }  
  
    static class OutPut{  
        public void output1(String str) {  
            synchronized (this) {  
                for (int i = 0; i < str.length(); i++) {  
                    System.out.print(str.charAt(i));  
                }  
                System.out.println();  
            }  
        }  
        public synchronized void output2(String str) {  
                for (int i = 0; i < str.length(); i++) {  
                    System.out.print(str.charAt(i));  
                }  
                System.out.println();  
            }  
        }  
        public static void output3(String str) {  
                synchronized (OutPut.class) {  
                for (int i = 0; i < str.length(); i++) {  
                    System.out.print(str.charAt(i));  
                }  
                System.out.println();  
            }  
            }  
          
      
  
}  


 


 


 


****** 传统多线程通信 *********


wait与notify实现线程之间的通信
    经验：要用到共同数据（包括同步锁）的若干方法应该归在同一个类身上，这种设计正好体现了高聚类和程序的健壮性


[java] view plaincopy
package TraditionalThread;  
  
public class TraditionalThreadCommunication {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        final Business business=new Business();  
        new Thread(  
                new Runnable() {  
                      
                    @Override  
                    public void run() {  
                        // TODO Auto-generated method stub  
                        for (int i = 0; i < 50; i++) {  
                            business.main(i);  
                        }  
                    }  
                }  
                ).start();  
          
        for (int i = 0; i < 50; i++) {  
            business.sub(i);  
        }  
    }  
}  
//单独写一个类用来处理输出  
class Business{  
    private boolean flag=true;  
    public synchronized void main(int i){  
                if (!flag) {  
                    try {  
                        this.wait();  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                }  
                for (int j = 0; j < 10; j++) {  
                    System.out.println("主线程调用第"+i+"轮,第"+j+"次");  
                }  
                flag=false;  
                this.notify();  
    }  
    public synchronized void sub(int i) {  
            if (flag) {  
                try {  
                    this.wait();  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
            for (int j = 0; j < 10; j++) {  
                System.out.println("子线程调用第"+i+"轮,第"+j+"次");  
            }  
            flag=true;  
            this.notify();  
    }  
}  


 


 


 


******** 线程范围内共享数据 *********


方法： 用map集合类来记住每个线程对应的只能自己使用的数据


Map<Thread,Integer> shareData=new HashMap<Thread, Integer>();//创建map集合类来存放线程和其对应资源


 


 


 


****** ThreadLocal实现线程范围的共享变量 **********


ThreadLocal<MyThreadScopData> mThreadLocal=new ThreadLocal<MyThreadScopData>();


  对象的set和get方法


 


 


 


 


***** 多个线程访问共享对象和数据的方式 *******




   如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据
   如果每个线程的代码不同，这时候就用不同的Runnable对象，有如下两种方法实现这些Runnable对象之间的数据共享
       1 将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象，每个线程对共享说句的操作方法也分配到那个对象身上去完成，这样很容易实现对该数据进行各个操作的互斥和通信
       2 将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行各个操作的互斥和通信，作为内部类的各个RUnnable对象调用外部类的这些方法
        上面两种结合，将共享数据封装到一个对象中，每个线程对恭喜那个数据的操作也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或者方法中的局部变量，每个线程的RUnnable对象作为外部类中的成员内部类或者局部内部类
         总之：要同步互斥的几段代码，最好是分别放在几个独立的方法中，这些方法在放到同一个类中，这样比较容易实现他们之间的同步互斥和通信




前两种的源码：


[java] view plaincopy
package TraditionalThread;  
  
public class MultiThreadShareData {  
  
    private static ShareData1 data1 = new ShareData1();  
      
    public static void main(String[] args) {  
        ShareData1 data2 = new ShareData1();  
        new Thread(new MyRunnable1(data2)).start();  
        new Thread(new MyRunnable2(data2)).start();  
          
        final ShareData1 data1 = new ShareData1();  
        new Thread(new Runnable(){  
            @Override  
            public void run() {  
                data1.decrement();  
                  
            }  
        }).start();  
        new Thread(new Runnable(){  
            @Override  
            public void run() {  
                data1.increment();  
                  
            }  
        }).start();  
  
    }  
  
}  
      
    class MyRunnable1 implements Runnable{  
        private ShareData1 data1;  
        public MyRunnable1(ShareData1 data1){  
            this.data1 = data1;  
        }  
        public void run() {  
            data1.decrement();  
              
        }  
    }  
      
    class MyRunnable2 implements Runnable{  
        private ShareData1 data1;  
        public MyRunnable2(ShareData1 data1){  
            this.data1 = data1;  
        }  
        public void run() {  
            data1.increment();  
        }  
    }  
  
    class ShareData1 /*implements Runnable*/{  
/*      private int count = 100; 
        @Override 
        public void run() { 
            // TODO Auto-generated method stub 
            while(true){ 
                count--; 
            } 
        }*/  
          
          
        private int j = 0;  
        public synchronized void increment(){  
            j++;  
        }  
          
        public synchronized void decrement(){  
            j--;  
        }  
    }  


第三种：
  思路：
      共享变量放到主函数外，定义内部类（增加和减少两个）实现Runnable接口
      创建线程之前，创建两个内部类的对象，然后再用for循环创建多个线程（其中增加减少操作也可以封装成互斥函数，便于同步）