File Sistem Terdistribusi

Distributed File System (DFS) adalah satu set layanan klien dan server yang memungkinkan sebuah organisasi menggunakan Microsoft Windows server untuk mengatur banyak terdistribusi SMB saham file ke sistem file terdistribusi . DFS menyediakan transparansi lokasi dan redundansi untuk meningkatkan ketersediaan data dalam menghadapi kegagalan atau beban berat dengan membiarkan saham di lokasi yang berbeda ganda untuk secara logis dikelompokkan dalam satu folder, atau akar DFS.
DFS Microsoft disebut secara bergantian sebagai 'DFS' dan 'DFS' oleh Microsoft dan tidak berhubungan dengan DCE Sistem file terdistribusi , yang memegang 'DFS' merek dagang  tetapi dihentikan pada 2005.
Hal ini juga disebut "MS-DFS" atau "MSDFS" dalam konteks tertentu, misalnya dalam Samba ruang pengguna proyek.

Tidak ada persyaratan untuk menggunakan dua komponen DFS bersama-sama, sangat mungkin untuk menggunakan komponen namespace logis tanpa menggunakan replikasi DFS file, dan sangat mungkin untuk menggunakan replikasi file antara server tanpa menggabungkan mereka menjadi satu namespace.
Sebuah akar DFS hanya bisa berada pada versi server Windows (dari Windows NT 4.0 ke atas) dan OpenSolaris [2] (dalam ruang kernel ) atau komputer yang menjalankan Samba (dalam ruang pengguna .) Para Edisi Enterprise dan pusat data dari Windows Server dapat host beberapa akar DFS pada server yang sama. OpenSolaris bermaksud untuk mendukung akar beberapa DFS dalam "proyek masa depan berdasarkan pada Active Directory (AD) domain berbasis DFS ruang nama". [3]
Ada dua cara penerapan DFS pada server:
  • Standalone DFS namespace memungkinkan untuk akar DFS yang hanya ada pada komputer lokal, dan dengan demikian tidak menggunakan Active Directory . Sebuah DFS Standalone hanya bisa diakses di komputer yang dibuat. Ini tidak menawarkan toleransi kesalahan dan tidak dapat terhubung ke setiap DFS lainnya. Ini adalah pilihan hanya tersedia pada Windows NT Server 4.0 sistem. Standalone DFS akar jarang ditemui karena utilitas mereka yang terbatas.
  • Domain berbasis DFS Namespace menyimpan konfigurasi DFS dalam Active Directory, akar namespace DFS dapat diakses di \ \ domainname \ atau \ \ fq.domain.name \ . Akar namespace tidak harus berada pada domain controller, mereka dapat berada pada server anggota, jika kontroler domain tidak digunakan sebagai root server namespace, maka server anggota beberapa harus digunakan untuk memberikan toleransi kesalahan penuh.
Isi
DFS ruang nama
Saham file tradisional, terkait dengan server tunggal, memiliki jalan SMB bentuk \ \ \ \ . Domain berbasis DFS path file saham dibedakan dengan menggunakan nama domain di tempat nama server, dalam bentuk \ \ \ \ . Ketika seorang pengguna mengakses seperti saham, baik secara langsung atau dengan pemetaan drive , komputer mereka akan mengakses salah satu server yang tersedia yang berhubungan dengan saham yang, mengikuti aturan yang dapat dikonfigurasi oleh administrator jaringan. Misalnya, perilaku default adalah bahwa pengguna akan mengakses server yang dekat dengan mereka, tetapi ini dapat diganti untuk lebih memilih server tertentu.
Jika server gagal, klien dapat memilih server yang berbeda transparan kepada pengguna. Satu peringatan utama mengenai fleksibilitas ini yang saat ini terbuka file yang berpotensi akan menjadi tidak dapat digunakan, seperti membuka file tidak dapat gagal-over

replikasi DFS
Versi awal DFS digunakan FRS yang menyediakan file kemampuan replikasi dasar antara server. FRS mengidentifikasi file yang berubah atau baru, dan salinan versi terbaru dari seluruh file untuk semua server.
Windows Server 2003 R2 memperkenalkan "Replika DFS" (DFSR) yang meningkatkan pada FRS dengan hanya menyalin bagian-bagian file yang telah berubah ( kompresi diferensial terpencil ), dengan menggunakan kompresi data untuk mengurangi lalu lintas jaringan, dan dengan memungkinkan administrator pilihan konfigurasi yang fleksibel untuk membatasi jaringan lalu lintas dengan jadwal yang disesuaikan

Sejarah
Komponen server dari File System Terdistribusi pertama kali diperkenalkan sebagai add-on untuk Windows NT 4.0 Server, yang disebut "DFS 4,1", [4] dan kemudian dimasukkan sebagai komponen standar dari semua edisi Windows 2000 Server. Windows NT 4.0 dan kemudian termasuk sisi klien dukungan untuk DFS. Versi 2.6.14 dan kemudian [5] dari kernel Linux datang dengan klien SMB VFS disebut "cifs" yang mendukung DFS. Thursby Software DAVE, ADmitMac dan PKI ADmitMac produk DFS dukungan komersial pada Mac OS X. [1] DFS dilaporkan didukung secara native di Mac OS X 10.7 ("Singa"). 





sumber : http://technet.microsoft.com/en-us/library/cc753479%28v=ws.10%29.aspx
Implementasi Thread dan Multithread Server

Multithreading mengacu kepada dua atau lebih task (tugas, thread) yang berjalan (sedang dieksekusi) di dalam satu program. Thread merupakan suatu path eksekusi independen di dalam program. Banyak thread dapat nerjalan secara konkuren (berbarengan) di dalam program. Setiap thread di dalam Java dibuat dan dikendalikan oleh kelas java.lang.Thread. Suatu program Java dapat mempunyai banyak thread, dan thread-thread ini dapat berjalan secara bersamaan, secara asinkron atau sinkron.
Multithreading mempunyai beberapa keuntungan, dibandingkan multiprocessing, di antaranya:
  • Thread bersifat lightweight, sedangkan proses lebih berat. Perlu diketahui bahwa proses adalah program yang sedang berada di memory atau processor, sedang dieksekusi. Thread dapat diartikan sebagai anak dari proses.
  • Thread-thread berbagi pakai ruang alamat yang sama dan karena itu dapat berbagi pakai data dan kode (instruksi)
  • Context switching antar thread biasanya lebih murah daripada antar proses.
  • Biaya komunikasi antar thread relatif lebih rendah daripada komunikasi antar proses.
  • Thread memungkinkan task-task berbeda dikerjakan secara konkuren.
Kelas Thread merupakan turunan dari kelas Object. Kelas Object sendiri mempunyai metode notify(), notifyAll() dan wait(), sedangkan kelas Thread menyediakan metode sleep() dan yield(). Metode-metode ini akan sering digunakan dalam pengelolaan aplikasi banyak thread.
Pembuatan Thread
Terdapat 2 (dua) cara membuat thread di dalam Java:
  • Mengimplementasikan interface Runnable (java.lang.Runnable)
  • Menurunkan (extend) kelas Thread (java.lang.Thread)
Mengimplementasikan Interface Runnable
Bentuk dasar (signature) dari interface Runnable adalah
1
public interface Runnable {
2
    void run();

3
}
Pada pendekatan ini, kita harus membuat sebuah kelas yang implementasi interface Runnable menggunakan kata kunci implements Runnable. Kemudian dibuat instansiasi berupa suatu obyek dari kelas itu. Kita perlu meng-override metode run() di dalam kelas itu, satu-satunya metode yang perlu diimplementasikan. Metode run() mengandung logika dari thread yang dibangun.


Prosedur pembuatan thread berdasarkan pendekatan interface Runnable adalah sebagai berikut:
  1. Sebuah kelas meng-implements interface Runnable, menyediakan metode run() di dalamnya yang akan dieksekusi oleh thread nantinya. Obyek dari kelas ini merupakan obyek Runnable.
  2. Obyek dari kelas Thread dibuat dengan melewatkan obyek Runnable sebagai argumen ke konstruktur Thread. Obyek Thread sekarang mempunyai suatu obyek Runnable yang mengimplementasikan metode run().
  3. Metode start() pada obyek Thread yang dibuat sebelumnya dipanggil. Metode start() tersebut kembali segera setelah suatu thread dilahirkan (berhasil dibuat).
  4. Thread berakhir ketika metode run() berakhir, baik dengan penyelesaian normal atau dengan melempar suatu eksepsi tidak tertangkap (uncaught exception).
Di bawah ini adalah sebuah program yang mengilustrasikan pembuatan thread menggunakan interfaca Runnable, bukan meng-extend kelas Thread. Suatu thread dimulai ketika kita memanggil metode start() pada obyek yang dibuat.
01
class RunnableThread implements Runnable {
02


03
    Thread runner;
04


05
    public RunnableThread() {   }
06


07
    public RunnableThread(String threadName) {
08
        runner = new Thread(this, threadName); // (1) Buat thread baru.

09
        System.out.println(runner.getName());
10
        runner.start(); // (2) Memulai eksekusi thread tersebut.

11
    }
12


13
    public void run() {
14
        //Tampilkan info tentang thread ini

15
        System.out.println(Thread.currentThread());
16
    }

17
}
18


19
public class RunnableExample {
20


21
    public static void main(String[] args) {
22
        Thread thread1 = new Thread(new RunnableThread(), "thread1");

23
        Thread thread2 = new Thread(new RunnableThread(), "thread2");
24
        RunnableThread thread3 = new RunnableThread("thread3");

25

26
        //Memulai eksekusi thread.

27
        thread1.start();
28
        thread2.start();

29
        try {
30
            //delay selama satu detik (1000 ms).

31
            Thread.currentThread().sleep(1000);
32
        } catch (InterruptedException e) {   }

33

34
        //Tampilkan info tentang thread main (utama).

35
        System.out.println(Thread.currentThread());
36
    }

37
}
Keluaran dari Program di atas dapat berupa:
thread3
Thread[thread1,5,main]
Thread[thread2,5,main]
Thread[thread3,5,main]
Thread[main,5,main]private
Pendekatan ini harus digunakan jika kelas yang menginstansiasi obyek thread diperlukan (sebagai parent) untuk membuat kelas-kelas lain yang merupakan keturunannya. Pada kasus demikian, kita tidak boleh menurunkan kelas Thread, harus mengimplementasikan Runnable.
Meng-Extend Kelas Thread
Prosedur pembuatan thread melalui pendekatan penurunan kelas Thread adalah sebagai berikut:
  1. Membuat sebuah sub-kelas turunan dari kelas Thread, kemudian meng-override metode run() dari kelas Thread dan di dalamnya didefinisikan beberapa kode yang dieksekusi oleh thread.
  2. Sub-kelas ini dapat memanggil suatu konstruktur Thread secara eksplisit untuk menginisialisasi thread, menggunakan metode super().
  3. Metode start() yang telah diturunkan (secara otomatis) dari kelas Thread dipanggil agar thread segera berjalan.
Berikut ini adalah sebuah program yang mengilustrasikan pembuatan thread dengan meng-extend kelas Thread sebagai ganti mengimplementasikan interface Runnable. Metode start() digunakan untuk mengeksekusi obyek thread yang dibuat.
01
class XThread extends Thread {
02


03
    XThread() {  }
04


05
    XThread(String threadName) {
06
        super(threadName); // Memulai thread.

07
        System.out.println(this);
08
        start();

09
    }
10


11
    public void run() {
12
        //Tampilkan info tentang thread ini

13
        System.out.println(Thread.currentThread().getName());
14
    }

15
}
16


17
public class ThreadExample {
18


19
    public static void main(String[] args) {
20
        Thread thread1 = new Thread(new XThread(), "thread1");

21
        Thread thread2 = new Thread(new XThread(), "thread2");
22


23
        // 2 thread diberikan nama default
24
        Thread thread3 = new XThread();

25
        Thread thread4 = new XThread();
26
        Thread thread5 = new XThread("thread5");

27

28
        //Memulai eksekusi thread

29
        thread1.start();
30
        thread2.start();

31
        thread3.start();
32
        thread4.start();

33
        try {
34
    //Metode sleep() dipanggil pada thred main (utama), delay 1 detik.

35
            Thread.currentThread().sleep(1000);
36
        } catch (InterruptedException e) {  }

37

38
        //Tampilkan info tentang thread main

39
        System.out.println(Thread.currentThread());
40
    }

41
}
Keluaran yang diperoleh dapat berupa:
Thread[thread5,5,main]
thread1
thread5
thread2
Thread-3
Thread-2
Thread[main,5,main]
Pada saat membuat thread, ada dua alasan mengapa kita mengimplementasikan interface Runnable, bukan meng-extend kelas Thread:
  • Menurunkan kelas Thread berarti bahwa subclass tidak dapat diturunkan menjadi kelas lain lagi, sedangkan suatu kelas yang mengimplementasikan interface Runnable mempunyai opsi ini.
  • Suatu kelas mungkin hanya diinginkan runnable, karena itu menurunkan Thread secara penuh merupakan pemborosan.
Contoh dari kelas anonim berikut memperlihatkan bagaimana membuat sebuah thread dan langsung menjalankannya:
1
( new Thread() {
2
   public void run() {

3
      for(;;) System.out.println(”Stop the world!”);
4
   }

5
}
6
).start();
  • Pengikut