JAVA多線程 & 同步關鍵詞synchronized & ReadWriteLock讀寫文件

　　在java中可有兩種方式實現多線程，一種是繼承Thread類，一種是實現Runnable接口；Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限。

public class Actor extends Thread  {
    public void run(){
         //線程執行的操作
        }
}   

　　在實際開發中一個多線程的操作很少使用Thread類，而是通過Runnable接口完成。

public class Actress implements Runnable{

    @Override
    public void run() {
        //線程執行的操作
        }
}    

　　在主方法中調用這兩種線程。

    public static void main(String[] args) {
        Thread actor=new Actor();
        actor.setName("Mr.thread");  //Thread 線程
        actor.start();
        
        Thread actressThread=new Thread(new Actress(),"Miss.Runnable");  //Runnable 線程
        actressThread.start();
    }

 

兩種實現方式的區別和聯系：

　　在程序開發中只要是多線程肯定永遠以實現Runnable接口為主，因為實現Runnable接口相比繼承Thread類有如下好處：

　　　　1、避免點繼承的局限，一個類可以繼承多個接口。

　　　　2、適合於資源的共享

　　以賣票程序為例，通過Thread類完成：

package multithreading;

public class MyThreadWithExtends extends Thread {

    private int tickets = 10;

    @Override
    public void run() {

        for (int i = 0; i <= 100; i++) {
            if(tickets>0){
                System.out.println(Thread.currentThread().getName()+"--賣出票：" + tickets--);
            }
        }
    }
    
    
    public static void main(String[] args) {
        MyThreadWithExtends thread1 = new MyThreadWithExtends();
        MyThreadWithExtends thread2 = new MyThreadWithExtends();
        MyThreadWithExtends thread3 = new MyThreadWithExtends();

        thread1.start();
        thread2.start();
        thread3.start();
        
        //每個線程都獨立，不共享資源，每個線程都賣出了10張票，總共賣出了30張。如果真賣票，就有問題了。
    }

}

運行結果：

　　Thread-0--賣出票：10
　　Thread-2--賣出票：10
　　Thread-1--賣出票：10
　　Thread-2--賣出票：9
　　Thread-0--賣出票：9
　　Thread-2--賣出票：8
　　Thread-1--賣出票：9
　　Thread-2--賣出票：7
　　Thread-0--賣出票：8
　　Thread-2--賣出票：6
　　Thread-2--賣出票：5
　　Thread-2--賣出票：4
　　Thread-1--賣出票：8
　　Thread-2--賣出票：3
　　Thread-0--賣出票：7
　　Thread-2--賣出票：2
　　Thread-2--賣出票：1
　　Thread-1--賣出票：7
　　Thread-0--賣出票：6
　　Thread-1--賣出票：6
　　Thread-0--賣出票：5
　　Thread-0--賣出票：4
　　Thread-1--賣出票：5
　　Thread-0--賣出票：3
　　Thread-1--賣出票：4
　　Thread-1--賣出票：3
　　Thread-1--賣出票：2
　　Thread-0--賣出票：2
　　Thread-1--賣出票：1
　　Thread-0--賣出票：1

 

　　如果用Runnable就可以實現資源共享，下面看例子：

package multithreading;

public class MyThreadWithImplements implements Runnable {

    private int tickets = 10;

    @Override
    public void run() {

        for (int i = 0; i <= 100; i++) {
            if(tickets>0){
                System.out.println(Thread.currentThread().getName()+"--賣出票：" + tickets--);
            }
        }
    }
    
    
    public static void main(String[] args) {
        MyThreadWithImplements myRunnable = new MyThreadWithImplements();
        Thread thread1 = new Thread(myRunnable, "窗口一");
        Thread thread2 = new Thread(myRunnable, "窗口二");
        Thread thread3 = new Thread(myRunnable, "窗口三");

        thread1.start();
        thread2.start();
        thread3.start();
    }

}

運行結果：

　　窗口二--賣出票：10
　　窗口三--賣出票：9
　　窗口一--賣出票：8
　　窗口三--賣出票：6
　　窗口三--賣出票：4
　　窗口三--賣出票：3
　　窗口三--賣出票：2
　　窗口三--賣出票：1
　　窗口二--賣出票：7
　　窗口一--賣出票：5

每個線程共享了對象myRunnable的資源，賣出的總票數是對的，但是順序是亂的，怎么辦？

 

同步關鍵詞synchronized

 

線程執行的時候，一個個執行不就有序了。即線程1在執行的時候，其他線程阻塞不要執行。

加synchronize。

package multithreading.sync;

public class MyThreadWithImplements implements Runnable {

    private int tickets = 10;

    @Override
    public synchronized void run() {
            //同步關鍵詞synchronized
        for (int i = 0; i <= 100; i++) {
            if(tickets>0){
                System.out.println(Thread.currentThread().getName()+"--賣出票：" + tickets--);
            }
        }
    }
    
    
    public static void main(String[] args) {
        
        MyThreadWithImplements myRunnable = new MyThreadWithImplements();
        Thread thread1 = new Thread(myRunnable, "窗口一");
        Thread thread2 = new Thread(myRunnable, "窗口二");
        Thread thread3 = new Thread(myRunnable, "窗口三");

        thread1.start();
        thread2.start();
        thread3.start();
    }

}

運行結果

　　窗口一--賣出票：10
　　窗口一--賣出票：9
　　窗口一--賣出票：8
　　窗口一--賣出票：7
　　窗口一--賣出票：6
　　窗口一--賣出票：5
　　窗口一--賣出票：4
　　窗口一--賣出票：3
　　窗口一--賣出票：2
　　窗口一--賣出票：1

 

缺陷

　　1、如果這個獲取鎖的線程由於要等待IO或者其他原因（比如調用sleep方法）被阻塞了，但是又沒有釋放鎖，其他線程便只能干巴巴地等待，這多么影響程序執行效率。

　　2、當有多個線程讀寫文件時，讀寫操作會發生沖突現象，寫操作會發生沖突現象，但是讀操作不會發生沖突現象。但是采用synchronized關鍵字來實現同步的話，就會導致一個問題：如果多個線程都只是進行讀操作，當一個線程在進行讀操作時，其他線程只能等待無法進行讀操作。

　　因此就需要一種機制來使得多個線程都只是進行讀操作時，線程之間不會發生沖突，通過Lock就可以辦到。另外，通過Lock可以知道線程有沒有成功獲取到鎖。這個是synchronized無法辦到的。總的來說，也就是說Lock提供了比synchronized更多的功能。

ReadWriteLock讀寫文件

概述

ReadWriteLock是一個接口，在它里面只定義了兩個方法：一個讀的鎖和一個寫的鎖。

讀的鎖：A線程獲取了讀的鎖，那么B線程也可以獲取讀的鎖。

寫的鎖：A線程獲取了寫的鎖，那么B線程不能獲取讀也不能獲取寫的鎖。

public interface ReadWriteLock {  
    /** 
     * Returns the lock used for reading. 
     * 讀的鎖，A線程獲取了讀的鎖，那么B線程也可以獲取讀的鎖 
     * @return the lock used for reading. 
     */  
    Lock readLock();  
   
    /** 
     * Returns the lock used for writing. 
     * 寫的鎖，A線程獲取了寫的鎖，那么B線程不能獲取讀也不能獲取寫的鎖。 
     * @return the lock used for writing. 
     */  
    Lock writeLock();  
} 

。。。未完待續