IPC

Semaphore
semaphore adalah variable atau tipe data abstrak yang digunakan untuk mengontrol akses, dengan beberapa proses, ke sumberdaya umum di paralallel programming.

contoh: producer-consumer problem yg muncul jika demand lebih besar daipada supply

Pipe

streaming data secara dua arah antara dua proses dengan standard I/O dan dibaca pada saat bersamaan

FILE Descriptor : int yg digunakan sebagai identifier dari file-file yang dibuka

FILE Descriptor standard:
0 -> stdin
1 -> stdout
2-> stderr

system call : cara program untuk memangil fungsi-gungsi yang disediakan kernel
contoh: open(), close(), fork(),dll.

umask(): mendifiniskan mask untuk filepermssion yg dibuat oleh suatu proses.kebalikan dari file permission,bisa menentukan prosedur dan melakukan systemcall

open(): utk membuka file, return nya int
close(): utk menutup file

IPC: mekanisme komunikasi antar proses yg berjalan pada 1 komputer

contoh: PIPE, message queue, shared memory, semaphore

unamed pipe.c
int file_descriptors[2];
pipe(file_descriptors);

pid_t spawned_process_pid = fork();

if(spawned_process_pid == 0) {
printf(“in the spawned (child) process…\n”);
}
else {
printf(“in the spawning (parent) process…\n”);
}


named pipe
Named pipe digunakan utk 2 proses yg berjalan sendiri2. Pipe jenis ini hanya bisa digunakan pada proses2 yg memakai filesytem yg sama memakai mknod

Thread -again-

Apa itu thread? secara garis besar thread adalah: 

• sesuatu yg berjalan dlm prosesor 
• bag yg lebih kecil dr sebuah proses 
• sekumpulan instruksi yg berjalan sekuensial

Thread bisa dibuat sebagai multithread yg tujuan pembuatannya sama dengan multiproses. Multithread lebih dianjurkan daripada multi proses karena waktu pembuatannnya lebih cepat

contoh 1p1t: ms-dos
    1pmt: jvm
    mp1t: unix tahun enam puluh-an
    mpmt: windows/os x/ubuntu


ciri2 proses:
- memiliki space sndiri utk process mage
- tdk dpt mengakses ruang lain d memori yg menjadi milik proses lain

ciri2 thread:
pny space sndiri TAPI bisa mengakses space lain || ada space yg berhak diakses oleh thread2

versi mini dr sbuah proses ,pny thread state jg dll.


keuntungan thread
lebih cepat dan efisien


contoh aplikasi multiple thread: mozilla firefox

per tab yg muncul adl per thread

kalo google chrome:
per ta yg muncul adl proses


knp google chrome pake multi proses? krn lebih aman


pake multi proses + multithread = APACHE
fungsi: file bs diakses d sluruh dunia

ctg penggunaan thread
1. foreground & background work
2. asinkronous prosessng
3. speed of eksekusi

thread state:
1. spawn  >dibuat os
2block > nunggu event
3unbloc
4finish


user lvl thread
ciri2: kernel tdk tahu thread. krn yg memantau adl library lain

keuntungan:
thread switching tdk butuh kernel mode privileges
dpt brjalan d berbagai os

kerugian:
1 thread brocked, thread lain jg sama yg satu proses
2 thread d proses yg sama tdk dpt berjalan pd dua prosesor



kernel level thread
ciri2
yg mantau kernel

keuntungan
bs jln d proses yg berbeda
kernel routines bs multthreaded

kerugian
memperlambat
melibatkan kernel apa2





hyer lvl thread
ada yg pake user, ada yg pake kernel




THREAD PROGRAMMING

thread di linux
menggunakan POSIX Standard Thread API
dikenal dg nama pthread

d compile dg option:
linking//kayak include

pmbuatan thread:
type var: pthread_t


fungsi buat thread:
int pthread_create<pthread_t .thread , const thread_attr_T .attr, void .<.start_routine> <void .>,void.arg>;

parameter
1. thread ID
2. thread atrribut /NULL kalo bingung
3. fungsi yg ingin dijalankan
4. parameter utk fungsi yg dijalanan


bagaimana jika parameter lbh dr satu?
pake STRUCT


menanti thread
thread dijadwal OS
user tdk tahu mana yg jalan duluan

fngsi utk menunggu eksekusi
int pthread_join
parameter:
1 thread id yg diunggu
2. var utk enimpan return value

All About Thread

Berikut ini adalah pengetahuan dasar tentang thread:

• Operasi Thread meliputi pembuatan , penghentian, sinkronisasi, penjadwalan, manajemen data, dan proses interaksi thread.
• Sebuah thread tidak menjaga/memelihara daftar thread yg dibuat dan tidak tahu thread yg membuat.
• Semua thread dalam sebuah proses memiliki alamat space yg sama.
• Thread2 yg berada pada proses yg sama membagi:
  • Instruksi proses
  • Data
  • descriptors
  • sinyal dan sinyal handler
  • direktori
  • User and group id
• Setiap thread memiliki:
  • Thread ID
  • set of registers, stack pointer
  • stack utk variable lokal, return addresses
  • signal mask
  • prioritas
  • Return value: errno
• pthread functions return "0" if OK.
•  

Sinkronisasi Thread
Library thread menyediakan 3 jenis sinkronisasi yaitu:

• mutexes - Mutual exclusion lock: Mem-block akses ke variable yg dilakukan thread lain. Ini memaksa akses ekslusif ole thread ke variable atau set variable
• joins - Membuat thread menunggu sampai thread lain selesai.
• condition variables - data type pthread_cond_t

 

Mutexes:

Mutexes digunakan untuk mencegah terjadinya inkonsistensi data karena operasi oleh thread2 yg berada di area memory yg sama dan dijalankan di saat yg sama atau mencegah terjadinya race condition. race condition sering terjadi saat dua thread atau lebih harus dilaksanakan di area memory yg sama, tapi hasil komputasinya tergantung dari urutan contention .

contoh mutex:

/* Note scope of variable and mutex are the same */
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter=0;

/* Function C */
void functionC()
{
   pthread_mutex_lock( &mutex1 );
   counter++
   pthread_mutex_unlock( &mutex1 );
} 

Joins:

join dibutuhkan saat thread ingin menunggu thread lain utk selsesai. thread yg memanggil routin bisa meluncurkan multiple thread lalu menunggu nya untuk selesai dan mendapatkan hasil.
contoh Join:

#include <stdio.h>
#include <pthread.h>

#define NTHREADS 10
void *thread_function(void *);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int  counter = 0;

main()
{
   pthread_t thread_id[NTHREADS];
   int i, j;

   for(i=0; i < NTHREADS; i++)
   {
      pthread_create( &thread_id[i], NULL, thread_function, NULL );
   }

   for(j=0; j < NTHREADS; j++)
   {
      pthread_join( thread_id[j], NULL); 
   }
  
   /* Now that all threads are complete I can print the final result.     */
   /* Without the join I could be printing a value before all the threads */
   /* have been completed.                                                */

   printf("Final counter value: %d\n", counter);
}

void *thread_function(void *dummyPtr)
{
   printf("Thread number %ld\n", pthread_self());
   pthread_mutex_lock( &mutex1 );
   counter++;
   pthread_mutex_unlock( &mutex1 );
} 

tentang multithreading

Sebenarnya multitasking dibagi menjadi 2 bagian; Process Based dan Thread Base. Process Based adalah multitasking saat suatu program dijalankan bersamaan dengan program lain dalam satu waktu. Contoh kasus suatu multitasking Process Based adalah bila kita sedang menulis laporan di OpenOffice sambil mencari referensi di Internet dengan menggunakan Software Mozila sebagai Software Browser dalam satu waktu. Hal ini kita sedang menggunakan 2 software dalam satu waktu.

Thread Base adalah multitasking saat suatu program dijalankan, program itu dapat melakukan proses – proses lain yang dilakukan bersamaan dalam suatu waktu. Contohnya adalah bila kita sedang mencetak suatu lembar laporan yang kita lakukan di OpenOffice misalnya. Kadang sambil menunggu cetakan selesai, kita biasa melihat-lihat cetakan selanjutnya yang akan dicetak, dan kadang kita juga mengedit tulisan dengan merubah ukuaran huruf atau warna huruf misalnya. Nah, inilah proses Thread Base multitasking yang terjadi dalam kegiatan tersebut.

Untuk menghemat waktu dan memaksimalkan kerja dari Processor yang memiliki kecepatan lebih dari pada device I/O, maka saat kita menunggu masukan atau keluaran dari device I/O, kita suruh si Processor mengerjakan kegiatan lain biar gak mubajir core 2 duonya..hehehe.
Dalam proses multitasking, ada keadaan yang mesti kita ketahui yaitu keadaan saat berjalan ( Running ) artinya adalah Processor menjalankan suatu kegiatan. Keadaan menghentikan sementara ( Suspend ) adalah kegiatan dari processor dihentikan sementara sampai keadaan dilanjutkan yaitu keadaan Resumed atau kadang keadaan pembatalan kegiatan processor ( Blocked ) dan terakhir keadaan selesai atau finishing ( Terminating ).




pada dasarnya di sistem pengerjaan itu ada 4:

1. 1 proses 1 thread
contoh: wordstar
2. multi proses 1 thread
contoh: google chrome,  per tab yg dibuka melahirkan proses baru, mangkanya kadang2 agak lama, tapi keunggulannya lebih aman
3. 1 proses multi thread
contoh: mozilla firefox, per tab melahirkan thread baru, cepat tapi kadang2 agak nge hang/not responding
 4. multiproses multi thread
contoh: linux , windows, dll.

PID

Seperti yang kita ketahui, setiap process dilinux selalu ada Process ID atau yang biasa disebut PID. PID ini adalah berupa nomer atau suatu angka tertentu yang unik disetiap processnya. Jadi tidak ada process yang mempunyai PID yang sama.
PID berguna untuk menghentikan atau mengunci suatu process dari aplikasi atau service. Dengan PID ini kita bisa menghentikan atau kill suatu process dan juga bisa melakukan blocking process apabila aplikasi/service itu sudah running. Sehingga kita bisa membatasi suatu applikasi/service hanya berjalan dengan process yang kita tentukan ( tidak ada double process ). Dan juga masih banyak lagi kegunaan dari PID ini.
Dilinux, PID bisa kita lihat dengan menggunakan perintah "ps". Tapi perintah ps ini menampilkan semua proses pada linux. Jadi kita harus memfilter lagi output dari ps untuk mendapatkan PID dari service yang kita inginkan.
Ada beberapa cara yang bisa dilakukan untuk memfilter PID dari ps. Salah satunya dengan menggunakan "grep" dan "awk" untuk mendapatkan PID yang diinginkan.
Contohnya:
# ps -ef | grep -i "firefox" | grep -v grep | awk '{print $2}'
outputnya adalah PID number dari firefox.
Berikut adalah contoh script killing PID yang saya buat:
#!/bin/bash
#Ganti dengan nama aplikasi yang mau dikill
APP=firefox
CHECK=`ps -ef | grep -i "$APP" | grep -v grep | awk '{print $2}' | wc -l`
if [ $CHECK -eq 0 ]; then
echo "No Process"; exit
elif [ $CHECK -gt 1 ]; then
echo "Double name Process. Try again and be more specific."; exit
fi
PID=`ps -ef | grep -i "$APP" | grep -v grep | awk '{print $2}'`
echo "killing pid $PID"
kill $PID
exit 0

Tentang Daemon dan IPC

Dalam Unix dan sistem operasi multitasking lainnya, Jurik atau Demit (Inggris: daemon)
Dalam bahasa Indonesia sendiri, daemon berarti Jurik atau Demit atau kita bisa menyebutnya Hantu. Ya memang benar jika dilihat dari sifatnya, daemon adalah sebuah proses yang bekerja di background serta tidak memiliki interface pengontrol (proses yang tidak terlihat).
Dalam keluarga Windows, service memiliki konsep yang sama dengan daemon. Service berjalan sebagai sebuah proses, umumnya tidak berinteraksi dengan keyboard, monitor dan mouse, serta pada umumnya prosesnya dimulai pada saat booting. Daemon biasanya bekerja untuk jangka waktu yang sangat lama dan bertugas "mendengarkan" request dan menjalankan responsnya.
Daemon process sendiri di Sistem Operasi Symbian dikenal dengan nama process saja. Contohnya process alarmserver.exe yang bertugas sebagai alarm server, btserver.exe pengendali Bluetooth, UsbWatcher.exe dan usbsrv.exe untuk pengendali USB kabel, dan masih banyak lagi hantu-hantu yang berkeliaran.
Dalam paket penginstalan Python S60 sudah tersedia python_launcher.exe yang siap dijalankan sebagai Daemon dengan parameter yang ditunjukan ke path python script.

contoh penerapan daemon:

Soal: membuat program yg berjalan di belakang layar, dimana jika kita membuat file format txt yg namanya tdk mengandung angka akan di pecah jadi 3 di folder tertentu

#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <dirent.h>
#include <sys/param.h>
#include <time.h>
//-------fungsi untuk memeriksa apakah filename mengandung angka atau tidak---------//
int cek(char inp[]){
//printf("msk fungsi cek.... arr= %s\n",inp);
int jml=strlen(inp);
int i;
int flag=0;
for(i=0;i<jml;i++){
//printf("karakter skrg: %c\n",inp[i]);
if(inp[i]=='0'||inp[i]=='1'||inp[i] == '2'|| inp[i]=='3'|| inp[i]=='4'|| inp[i]=='5'|| inp[i]=='6'|| inp[i]=='7'|| inp[i]=='8'|| inp[i]=='9')
{
//printf("file ini mengandung angka\n");
flag=1;
break;
}
}
if (flag==1) return 1;
else return 0;
}

//-----------------------------------------------------------------------------------//

            FILE* file[3]; //--deklarasi var file yg nanti jadi 3--//
        FILE* edit;    //--deklarasi var file utama--//
        FILE* loga;    //--deklarasi var file log--//


//-------------------fungsi utama---------------------------------------------------//
int walker() {
  DIR           *d;
  struct dirent *dir;
  d = opendir( "." );

//loga=fopen("log","w+");




  if( d == NULL ) {
    return 1;
  }

  while( ( dir = readdir( d ) ) ) {   //mulai membaca direktori




//    printf("FILE/folder skrg: %s\n",dir->d_name); 
    if( strcmp( dir->d_name, "." ) == 0 ||
        strcmp( dir->d_name, ".." ) == 0 ) {
      continue;
    }
    if( dir->d_type == DT_DIR ) { //jika folder maka akan ditelusuri
//        printf("pndh dir\n"); 
      chdir( dir->d_name );
      walker( );
      chdir( ".." );
    } else {
      char arr[100];
    char arr2[100];
        strcpy(arr2,dir->d_name);
//puts("mau di cek");     

//cek apa dia berformat txt atau tidak
int format=strlen(arr2);
//printf("format: %c%c%c%c\n",arr2[format-4],arr2[format-3],arr2[format-2],arr2[format-1]);


//printf("file yg diperiksa %s\n",arr2);



    int tes;  
    tes= cek(arr2);
    if(tes==1); //printf("mengandung angka: %s\n",arr2);

    else {

//------memeriksa apakah format file txt atau bukan--------------//
        if(arr2[format-4]=='.'&& arr2[format-3]=='t' && arr2[format-2]=='x' && arr2[format-1]=='t' ){
    int cop;
    for(cop=0;cop<format-4;cop++){            //jika benar maka nama file akan diambil utk dijadikan nama
//    puts("masuk cop");                //pada 3 file yg baru
    arr[cop]=arr2[cop];
    }
//    printf("file yg akan dipecah %s\n",arr);
          
//--------------------------------------------------------------//
            char tampung[100];
            char tmp[100];
            edit=fopen(arr2,"r"); //file utama dibuka

//----------make log file----------------//


    loga=fopen("/home/nuning/TES/log","a");
    fprintf(loga,"%s        ",arr2);

     struct tm *sTm;
    char buff[20];
    time_t now = time (0);
    sTm = localtime (&now);

     strftime (buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", sTm);
    fprintf (loga,"%s\n", buff);



//-------------------------------------//








//-----------------------proses penamaan 3 file----------------------------//

            snprintf(tampung, sizeof(char) * 100, "%s_1.txt", arr);
            file[0] = fopen(tampung, "w+");
        memset(tampung,0,sizeof(tampung));
        snprintf(tampung, sizeof(char) * 100, "%s_2.txt", arr);
             file[1] = fopen(tampung, "w+");
        memset(tampung,0,sizeof(tampung));
            snprintf(tampung, sizeof(char) * 100, "%s_3.txt", arr);
            file[2] = fopen(tampung, "w+");
        memset(tampung,0,sizeof(tampung));
//------------------------------------------------------------------------//


//----proses penyalinan--------//
int i=0;
while(fgets(tmp,100,edit) != NULL){
//printf("pemindahan\n");
fprintf(file[i % 3],"%s",tmp);
i++;

}
//----------------------------//
//puts("done");

        //menutup kembali file
        fclose(file[0]);
        fclose(file[1]);
        fclose(file[2]);
fclose(loga);
        fclose(edit);
        remove(arr2);
        //-----------------------
}
   
   
  }
 
 
  }

}

  closedir( d ); //menutup direktori
}

int main ()
{
    //------------Daemon------------------//
    pid_t pid, ppid, sid;
    pid=fork();
   
    if(pid == 0){
//        printf("--%d\n", getpid());
}

    if(pid > 0){
//        printf("--%d\n", getpid());
        exit(EXIT_SUCCESS);}
   
    //------------------------------------//


while(1)
    {
chdir ("/home/nuning/TES");

walker();
sleep(30);  
        umask(0);
    }
}

IPC

IPC (Inter-Process Communication) adalah komunikasi antar proses untuk mengirim data dari satu proses ke proses yang lain, baik antar proses dalam satu komputer maupun proses-proses dalam komputer yang berbeda. IPC dapat dilakukan dengan berbagai cara yaitu Shared memory, Pipe, Messages passing, dan sebagainya. Berikut penjelasan mengenai cara-cara tersebut.

a.      Shared memory

Sistem Berbagi Memori atau yang disebut juga sebagai Shared Memory System merupakan salah satu cara komunikasi antar proses dengan cara mengalokasikan suatu alamat memori untuk dipakai berkomunikasi antar proses. Alamat dan besar alokasi memori yang digunakan biasanya ditentukan oleh pembuat program. Pada metode ini, sistem akan mengatur proses mana yang akan memakai memori pada waktu tertentu sehingga pekerjaan dapat dilakukan secara efektif.

b.      Pipe

Pipe merupakan komunikasi sequensial antar proses yang saling terelasi, namun pipe memiliki kelemahan yaitu hanya bisa digunakan untuk komunikasi antar proses yang saling berhubungan, dan komunikasinya yang dilakukan adalah secara sequensial. Urutan informasi yang ada dalam sebuah pipe ada yang mirip dengan antrian queue. Jika komunikasi yang diinginkan adalah komunikasi dua arah maka kita harus membuat dua pipe, karena sebuah pipe hanya bisa digunakan untuk komunikasi satu arah saja.

c.       Messages passing

Sistem berkirim pesan adalah proses komunikasi antar bagian sistem untuk membagi variabel yang dibutuhkan. Proses ini menyediakan dua operasi yaitu mengirim pesan dan menerima pesan. Ketika dua bagian sistem ingin berkomunikasi satu sama lain, yang harus dilakukan pertama kali adalah membuat sebuah link komunikasi antara keduanya. Setelah itu, kedua bagian itu dapat saling bertukar pesan melalui link komunikasi tersebut. Sistem berkirim pesan sangat penting dalam sistem operasi. Karena dapat diimplementasikan dalam banyak hal seperti pembagian memori, pembagian bus, dan melaksanakan proses yang membutuhkan pengerjaan bersama antara beberapa bagian sistem operasi. Terdapat dua macam cara berkomunikasi, yaitu:

1.       Komunikasi langsung

Setiap proses yang ingin berkomunikasi harus memiliki nama yang bersifat eksplisit  baik penerimaan atau pengirim dari komunikasi tersebut. Dalam konteks ini, pengiriman dan penerimaan pesan secara primitive dapat dijabarkan sebagai :

• Send (P, message) – mengirim sebuah pesan ke proses P.
• Receive (Q, message) – menerima sebuah pesan dari proses Q.

Sebuah jaringan komunikasi pada bahasan ini memiliki beberapa sifat, yaitu:

• Sebuah jaringan yang didirikan secara otomatis diantara setiap pasang dari proses yang ingin dikomunikasikan. Proses tersebut harus mengetahui identitas dari semua yang ingin dikomunikasikan.
• Sebuah jaringan adalah terdiri dari penggabungan dua proses.
• Diantara setiap pesan dari proses terdapat tepat sebuah jaringan.

Pembahasan ini memperlihatkan sebuah cara simetris dalam pemberian alamat. Oleh karena itu, baik keduanya yaitu pengirim dan penerima proses harus memberi nama bagi yang lain untuk berkomunikasi, hanya pengirim yang memberikan nama bagi penerima sedangkan penerima tidak menyediakan nama bagi pengirim. Dalam konteks ini, pengirim dan penerima secara sederhana dapat dijabarkan sebagai berikut:

• Send (P, message) – mengirim sebuah pesan kepada proses P.
• Receive (id, message) – menerima sebuah pesan dari semua proses. Variabel id diatur sebagai nama dari proses dengan komunikasi.

2.       Komunikasi tidak langsung

Dengan komunikasi tidak langsung, pesan akan dikirimkan pada dan diterima dari/ melalui mailbox (kotak surat) atau terminal-terminal, sebuah mailbox dapat dilihat secara abstrak sebagai sebuah objek didalam setiap pesan yang dapat ditempatkan dari proses dan dari setiap pesan yang bias dipindahkan. Setiap kotak surat memiliki sebuah identifikasi (identitas) yang unik, sebuah proses dapat berkomunikasi dengan beberapa proses lain melalui sebuah nomor dari mailbox yang berbeda.

Dua proses dapat saling berkomunikasi apabila kedua proses tersebut sharing mailbox. Pengirim dan penerima dapat dijabarkan sebagai :

• Send (A, message) – mengirim pesan ke mailbox A.
• Receive (A, message) – menerima pesan dari mailbox A.

Dalam masalah ini, link komunikasi mempunyai sifat sebagai berikut :

• Sebuah link dibangun diantara sepasang proses dimana kedua proses tersebut membagi mailbox.
• Sebuah link mungkin dapat berasosiasi dengan lebih dari dua proses.
• Diantara setiap pasang proses komunikasi, mungkin terdapat link yang berbeda-beda, dimana setiap link berhubungan pada satu mailbox.

Misalkan terdapat proses P1, P2 dan P3 yang semuanya share mailbox. Proses P1 mengirim pesan ke A, ketika P2 dan P3 masing-masing mengeksekusi sebuah kiriman dari A. Proses mana yang akan menerima pesan yang dikirim P1? Jawabannya tergantung dari jalur yang kita pilih :

• Mengizinkan sebuah link berasosiasi dengan paling banyak 2 proses.
• Mengizinkan paling banyak satu proses pada suatu waktu untuk mengeksekusi hasil kiriman (receive operation).
• Mengizinkan sistem untuk memilih secara mutlak proses mana yang akan menerima pesan (apakah itu P2 atau P3 tetapi tidak keduanya, tidak akan menerima pesan). Sistem mungkin mengidentifikasi penerima kepada pengirim.

Mailbox mungkin dapat dimiliki oleh sebuah proses atau sistem operasi. Jika mailbox dimiliki oleh proses, maka kita mendefinisikan antara pemilik (yang hanya dapat menerima pesan melalui mailbox) dan pengguna dari mailbox (yang hanya dapat mengirim pesan ke mailbox).

Selama setiap mailbox mempunyai kepemilikan yang unik, maka tidak akan ada kebingungan tentang siapa yang harus menerima pesan dari mailbox. Ketika proses yang memiliki mailbox tersebut diterminasi, mailbox akan hilang. Semua proses yang mengirim pesan ke mailbox ini diberi pesan bahwa mailbox tersebut tidak lagi ada. Dengan kata lain, mempunyai mailbox sendiri yang independent, dan tidak melibatkan proses yang lain. Maka sistem operasi harus memiliki mekanisme yang mengizinkan proses untuk melakukan hal-hal dibawah ini:

• Membuat mailbox baru.
• Mengirim dan menerima pesan melalui mailbox.
• Menghapus mailbox.

Proses yang membuat mailbox pertama kali secara default akan memiliki mailbox tersebut. Untuk pertama