Apa perbedaan antara konkurensi dan paralelisme?

Contohnya dihargai.

Concurrency adalah ketika dua atau lebih tugas dapat dimulai, dijalankan, dan selesai dalam periode waktu yang tumpang tindih. Itu tidak selalu berarti mereka berdua akan berjalan pada saat yang sama. Misalnya, multitasking pada mesin single-core.

Paralelisme adalah ketika tugas secara harfiah berjalan pada saat yang sama, misalnya pada prosesor multicore.

Mengutip Panduan Pemrograman Multithreaded Sun :

• Concurrency: Suatu kondisi yang ada ketika setidaknya dua utas membuat kemajuan. Suatu bentuk paralelisme yang lebih umum yang dapat mencakup pemotongan waktu sebagai bentuk paralelisme virtual.

• Paralelisme: Suatu kondisi yang muncul ketika setidaknya dua utas mengeksekusi secara bersamaan.

Mengapa Kebingungan Ada

Ada kebingungan karena arti kamus dari kedua kata ini hampir sama:

• Bersamaan : ada, terjadi, atau dilakukan pada saat yang sama (dictionary.com)
• Paralel : sangat mirip dan sering terjadi pada saat bersamaan (merriam webster).

Namun cara mereka digunakan dalam ilmu komputer dan pemrograman sangat berbeda. Inilah interpretasi saya:

• Concurrency : Interruptability
• Paralelisme : Independensi

Jadi apa yang saya maksud dengan definisi di atas?

Saya akan mengklarifikasi dengan analogi dunia nyata. Katakanlah Anda harus menyelesaikan 2 tugas yang sangat penting dalam satu hari:

1. Dapatkan paspor
2. Selesaikan presentasi

Sekarang, masalahnya adalah bahwa tugas-1 mengharuskan Anda pergi ke kantor pemerintah yang sangat birokratis yang membuat Anda menunggu selama 4 jam dalam antrean untuk mendapatkan paspor Anda. Sementara itu, tugas-2 diperlukan oleh kantor Anda, dan itu adalah tugas penting. Keduanya harus selesai pada hari tertentu.

Kasus 1: Eksekusi Berurutan

Biasanya, Anda akan pergi ke kantor paspor selama 2 jam, menunggu dalam antrean selama 4 jam, menyelesaikan tugas, kembali dua jam, pulang, tetap bangun 5 jam lagi dan menyelesaikan presentasi.

Kasus 2: Eksekusi Bersamaan

Tapi kamu pintar. Anda merencanakan ke depan. Anda membawa laptop, dan sambil menunggu di barisan, Anda mulai mengerjakan presentasi Anda. Dengan cara ini, setelah Anda kembali ke rumah, Anda hanya perlu bekerja 1 jam tambahan, bukan 5.

Dalam hal ini, kedua tugas dilakukan oleh Anda, hanya berkeping-keping. Anda mengganggu tugas paspor sambil menunggu di barisan dan mengerjakan presentasi. Ketika nomor Anda dipanggil, Anda menyela tugas presentasi dan beralih ke tugas paspor. Penghematan waktu pada dasarnya dimungkinkan karena interupsi dari kedua tugas.

Concurrency, IMO, dapat dipahami sebagai properti "isolasi" di ACID . Dua transaksi basis data dianggap terisolasi jika sub-transaksi dapat dilakukan dengan cara yang saling terkait dan hasil akhirnya sama seperti jika dua tugas dilakukan secara berurutan. Ingat, bahwa untuk tugas paspor dan presentasi, Anda adalah satu-satunya pelaksana .

Kasus 3: Eksekusi Paralel

Sekarang, karena kamu orang yang sangat pintar, kamu jelas-jelas atasan, dan kamu punya asisten. Jadi, sebelum Anda pergi untuk memulai tugas paspor, Anda memanggilnya dan memberitahunya untuk menyiapkan draf pertama presentasi. Anda menghabiskan seluruh hari dan menyelesaikan tugas paspor, kembali dan melihat surat-surat Anda, dan Anda menemukan konsep presentasi. Dia telah melakukan pekerjaan yang cukup solid dan dengan beberapa pengeditan dalam 2 jam lagi, Anda menyelesaikannya.

Sekarang karena, asisten Anda sama pintarnya dengan Anda, ia dapat mengerjakannya secara mandiri , tanpa harus terus-menerus meminta klarifikasi kepada Anda. Dengan demikian, karena independensi tugas, mereka dilakukan pada saat yang sama oleh dua algojo yang berbeda .

Masih dengan saya? Baik...

Kasus 4: Bersamaan Tapi Tidak Bersamaan

Ingat tugas paspor Anda, di mana Anda harus mengantri? Karena itu adalah paspor Anda , asisten Anda tidak dapat mengantri untuk Anda. Dengan demikian, tugas paspor memiliki interupsi (Anda dapat menghentikannya sambil menunggu di antrian, dan melanjutkannya nanti ketika nomor Anda dipanggil), tetapi tidak ada independensi (asisten Anda tidak dapat menunggu menggantikan Anda).

Kasus 5: Paralel Tapi Tidak Bersamaan

Misalkan kantor pemerintah memiliki pemeriksaan keamanan untuk memasuki tempat. Di sini, Anda harus menghapus semua perangkat elektronik dan mengirimkannya ke petugas, dan mereka hanya mengembalikan perangkat Anda setelah Anda menyelesaikan tugas Anda.

Dalam hal ini, tugas paspor tidak independen atau interruptible . Bahkan jika Anda sedang menunggu dalam antrean, Anda tidak dapat mengerjakan sesuatu yang lain karena Anda tidak memiliki peralatan yang diperlukan.

Demikian pula, katakan bahwa presentasi ini sangat matematis sehingga Anda memerlukan konsentrasi 100% selama minimal 5 jam. Anda tidak dapat melakukannya sambil menunggu dalam antrean tugas paspor, bahkan jika Anda membawa laptop Anda.

Dalam hal ini, tugas presentasi tidak dapat dilakukan sendiri (baik Anda atau asisten Anda dapat melakukan upaya fokus selama 5 jam), tetapi tidak dapat terputus .

Kasus 6: Eksekusi Bersamaan dan Paralel

Sekarang, katakan bahwa selain menugaskan asisten Anda ke presentasi, Anda juga membawa laptop untuk tugas paspor. Sambil menunggu di barisan, Anda melihat bahwa asisten Anda telah membuat 10 slide pertama di dek bersama. Anda mengirim komentar tentang karyanya dengan beberapa koreksi. Kemudian, ketika Anda tiba di rumah, alih-alih 2 jam untuk menyelesaikan draft, Anda hanya perlu 15 menit.

Ini dimungkinkan karena tugas presentasi memiliki kemandirian (salah satu dari Anda dapat melakukannya) dan interupsi (Anda dapat menghentikannya dan melanjutkannya nanti). Jadi, Anda menjalankan kedua tugas secara bersamaan , dan menjalankan tugas presentasi secara paralel.

Katakanlah, di samping birokrasi yang terlalu, kantor pemerintah korup. Dengan demikian, Anda dapat menunjukkan identitas Anda, memasukkannya, mulai menunggu dalam antrean untuk nomor Anda dipanggil, menyuap penjaga dan orang lain untuk memegang posisi Anda dalam antrean, menyelinap keluar, kembali sebelum nomor Anda dipanggil, dan melanjutkan menunggu dirimu sendiri.

Dalam hal ini, Anda dapat melakukan tugas paspor dan presentasi secara bersamaan dan paralel. Anda dapat menyelinap keluar, dan posisi Anda dipegang oleh asisten Anda. Anda berdua dapat mengerjakan presentasi, dll.

Kembali ke Ilmu Komputer

Dalam dunia komputasi, berikut adalah skenario contoh khas dari masing-masing kasus ini:

• Kasus 1: Pemrosesan interupsi.
• Kasus 2: Ketika hanya ada satu prosesor, tetapi semua tugas yang dieksekusi memiliki waktu tunggu karena I / O.
• Kasus 3: Sering terlihat ketika kita berbicara tentang kluster pengurangan peta atau hadoop.
• Kasus 4: Saya pikir Kasus 4 jarang. Ini tidak biasa untuk tugas yang bersamaan tetapi tidak paralel. Tapi itu bisa terjadi. Misalnya, tugas Anda memerlukan akses ke chip komputasi khusus yang hanya dapat diakses melalui prosesor-1. Jadi, bahkan jika prosesor-2 bebas dan prosesor-1 melakukan beberapa tugas lain, tugas perhitungan khusus tidak dapat dilanjutkan pada prosesor-2.
• Kasus 5: juga langka, tetapi tidak sesering kasus 4. Kode non-konkuren dapat menjadi wilayah kritis yang dilindungi oleh mutex. Setelah dimulai, itu harus dijalankan hingga selesai. Namun, dua wilayah kritis yang berbeda dapat berkembang secara bersamaan pada dua prosesor yang berbeda.
• Kasus 6: IMO, sebagian besar diskusi tentang pemrograman paralel atau bersamaan pada dasarnya berbicara tentang Kasus 6. Ini adalah campuran dan kecocokan dari eksekusi paralel dan bersamaan.

Concurrency dan Go

Jika Anda melihat mengapa Rob Pike mengatakan konkurensi lebih baik, Anda harus memahami alasannya. Anda memiliki tugas yang sangat panjang di mana ada beberapa periode menunggu di mana Anda menunggu beberapa operasi eksternal seperti membaca file, mengunduh jaringan. Dalam ceramahnya, semua yang ia katakan adalah, "putus saja tugas panjang yang berurutan ini sehingga Anda bisa melakukan sesuatu yang berguna saat Anda menunggu." Itu sebabnya dia berbicara tentang organisasi yang berbeda dengan berbagai pedagang.

Sekarang kekuatan Go berasal dari membuat pemecahan ini sangat mudah go kata kunci dan saluran. Juga, ada dukungan mendasar yang sangat baik dalam runtime untuk menjadwalkan goroutine ini.

Tetapi pada dasarnya, apakah konkurensi lebih baik daripada paralelisme?

Apakah apel lebih baik dari jeruk?

Saya suka ceramah Rob Pike: Konkurensi bukanlah Paralelisme (lebih baik!) (Slide) (bicara)

Rob biasanya berbicara tentang Go dan biasanya membahas pertanyaan Concurrency vs Parallelism dalam penjelasan visual dan intuitif! Berikut ini ringkasan singkatnya:

Tugas: Mari kita bakar tumpukan buku pedoman bahasa yang sudah usang! Satu per satu!

Concurrency: Ada banyak pembusukan tugas secara bersamaan! Satu contoh:

Paralelisme: Konfigurasi sebelumnya terjadi secara paralel jika setidaknya ada 2 akan bekerja pada saat yang sama atau tidak.

Untuk menambahkan apa yang dikatakan orang lain:

Konkurensi seperti memiliki juggler menyulap banyak bola. Terlepas dari bagaimana kelihatannya, juggler hanya menangkap / melempar satu bola per tangan sekaligus. Paralelisme memiliki beberapa juggler menyulap bola secara bersamaan.

Katakanlah Anda memiliki program yang memiliki dua utas. Program ini dapat berjalan dalam dua cara:

Concurrency                 Concurrency + parallelism
(Single-Core CPU)           (Multi-Core CPU)
 ___                         ___ ___
|th1|                       |th1|th2|
|   |                       |   |___|
|___|___                    |   |___
    |th2|                   |___|th2|
 ___|___|                    ___|___|
|th1|                       |th1|
|___|___                    |   |___
    |th2|                   |   |th2|

Dalam kedua kasus kami memiliki konkurensi dari fakta bahwa kami memiliki lebih dari satu utas berjalan.

Jika kami menjalankan program ini di komputer dengan inti CPU tunggal, OS akan beralih di antara dua utas, yang memungkinkan satu utas berjalan pada satu waktu.

Jika kita menjalankan program ini pada komputer dengan CPU multi-core maka kita akan dapat menjalankan kedua utas secara paralel - berdampingan pada saat yang bersamaan.

Konkurensi: Jika dua atau lebih masalah diselesaikan oleh satu prosesor.

Paralelisme: Jika satu masalah diselesaikan oleh beberapa prosesor.

Saya akan mencoba menjelaskan dengan contoh yang menarik dan mudah dipahami. :)

Asumsikan bahwa organisasi menyelenggarakan turnamen catur di mana 10 pemain ( dengan keterampilan bermain catur yang sama ) akan menantang seorang juara profesional pemain catur . Dan karena catur adalah permainan 1: 1, maka penyelenggara harus melakukan 10 pertandingan dengan waktu yang efisien sehingga mereka dapat menyelesaikan seluruh acara secepat mungkin.

Semoga skenario berikut ini akan dengan mudah menjelaskan beberapa cara melakukan 10 game ini:

1) SERIAL - katakanlah bahwa profesional bermain dengan setiap orang satu per satu yaitu memulai dan menyelesaikan permainan dengan satu orang dan kemudian memulai permainan berikutnya dengan orang berikutnya dan seterusnya. Dengan kata lain, mereka memutuskan untuk melakukan permainan secara berurutan. Jadi jika satu game membutuhkan waktu 10 menit untuk menyelesaikannya maka 10 game akan memakan waktu 100 menit, juga asumsikan bahwa transisi dari satu game ke game lain membutuhkan 6 detik maka untuk 10 game akan menjadi 54 detik (sekitar 1 menit).

jadi seluruh acara akan selesai dalam 101 menit ( PENDEKATAN TERBURUK )

2) CONCURRENT - misalkan profesional memainkan gilirannya dan beralih ke pemain berikutnya sehingga semua 10 pemain bermain secara bersamaan tetapi pemain profesional tidak dengan dua orang sekaligus, ia memainkan gilirannya dan beralih ke orang berikutnya. Sekarang anggap pemain profesional membutuhkan waktu 6 detik untuk memainkan gilirannya dan juga waktu transisi pemain profesional dengan dua pemain adalah 6 detik sehingga total waktu transisi untuk kembali ke pemain pertama adalah 1 menit (10x6detik). Oleh karena itu, pada saat dia kembali ke orang pertama dengan siapa, acara dimulai, 2mins telah berlalu (10xtime_per_turn_by_champion + 10xtransition_time = 2mins)

Dengan asumsi bahwa semua pemain mengambil 45 detik untuk menyelesaikan giliran mereka berdasarkan 10 menit per game dari acara SERIAL no. putaran sebelum pertandingan selesai harus 600 / (45 + 6) = 11 putaran (rata-rata)

Jadi keseluruhan acara akan selesai dalam 11xtime_per_turn_by_player _ & _ champion + 11xtransition_time_across_10_players = 11x51 + 11x60sec = 561 + 660 = 1221sec = 20.35mins (kurang-lebih)

Lihat peningkatan dari 101 menit menjadi 20,35 menit ( PENDEKATAN LEBIH BAIK )

3) PARALLEL - misalkan penyelenggara mendapatkan dana tambahan dan dengan demikian memutuskan untuk mengundang dua pemain juara profesional (keduanya sama-sama berkemampuan) dan membagi set 10 pemain (penantang) yang sama dalam dua kelompok yang terdiri dari masing-masing 5 dan menugaskan mereka ke dua juara yaitu satu kelompok masing-masing. Sekarang acara berlangsung secara paralel dalam dua set ini yaitu setidaknya dua pemain (satu di setiap grup) bermain melawan dua pemain profesional di grup masing-masing.

Namun dalam grup pemain profesional dengan mengambil satu pemain pada satu waktu (yaitu secara berurutan) sehingga tanpa perhitungan apa pun Anda dapat dengan mudah menyimpulkan bahwa seluruh acara akan kira-kira selesai dalam 101/2 = 50,5 mnt untuk diselesaikan

Lihat peningkatan dari 101 menit menjadi 50,5 menit ( PENDEKATAN YANG BAIK )

4) CONCURRENT + PARALLEL - Dalam skenario di atas, katakanlah bahwa dua pemain juara akan bermain secara bersamaan (baca poin ke-2) dengan 5 pemain di grup masing-masing sehingga sekarang permainan lintas grup berjalan secara paralel tetapi di dalam grup mereka berjalan bersamaan.

Jadi game dalam satu grup kira-kira akan selesai dalam 11xtime_per_turn_by_player _ & _ champion + 11xtransition_time_across_5_players = 11x51 + 11x30 = 600 + 330 = 930sec = 15.5mins (kurang-lebih)

Jadi seluruh acara (melibatkan dua kelompok berjalan paralel) kira-kira akan selesai dalam 15,5 menit

Lihat peningkatan dari 101 menit menjadi 15,5 menit ( PENDEKATAN TERBAIK )

CATATAN: dalam skenario di atas jika Anda mengganti 10 pemain dengan 10 pekerjaan serupa dan dua pemain profesional dengan dua core CPU, sekali lagi urutan berikut akan tetap benar:

SERIAL> PARALLEL> CONCURRENT> CONCURRENT + PARALLEL

(CATATAN: pesanan ini dapat berubah untuk skenario lain karena pemesanan ini sangat tergantung pada saling ketergantungan pekerjaan, kebutuhan komunikasi pekerjaan b / w dan overhead transisi pekerjaan b / w)

Contoh sederhana:

Bersamaan adalah: "Dua antrian mengakses satu mesin ATM"

Paralel adalah: "Dua antrian dan dua mesin ATM"

Bayangkan belajar bahasa pemrograman baru dengan menonton video tutorial. Anda perlu menjeda video, menerapkan apa yang dikatakan dalam kode kemudian melanjutkan menonton. Itu konkurensi.

Sekarang Anda seorang programmer profesional. Dan Anda menikmati mendengarkan musik yang tenang saat coding. Itu Paralelisme.

Seperti yang dikatakan Andrew Gerrand di GoLang Blog

Concurrency adalah tentang berurusan dengan banyak hal sekaligus. Paralelisme adalah tentang melakukan banyak hal sekaligus.

Nikmati.

Mereka memecahkan masalah yang berbeda. Concurrency memecahkan masalah memiliki sumber daya CPU yang langka dan banyak tugas. Jadi, Anda membuat utas atau jalur independen eksekusi melalui kode untuk berbagi waktu pada sumber daya yang langka. Hingga saat ini, concurrency mendominasi diskusi karena ketersediaan CPU.

Paralelisme memecahkan masalah menemukan tugas yang cukup dan tugas yang sesuai (tugas yang dapat dipisahkan dengan benar) dan mendistribusikannya ke sumber daya CPU yang berlimpah. Paralelisme selalu ada tentu saja, tetapi ia datang ke permukaan karena prosesor multi-core sangat murah.

concurency: alur eksekusi berganda dengan potensi untuk berbagi sumber daya

Mis: dua utas bersaing untuk port I / O.

paralelisme: memecah masalah dalam beberapa potongan serupa.

Mis: parsing file besar dengan menjalankan dua proses pada setiap setengah file.

Eksekusi pemrograman bersamaan memiliki 2 jenis: pemrograman konkuren non-paralel dan pemrograman paralel bersamaan (juga dikenal sebagai paralelisme).

Perbedaan utama adalah bahwa bagi mata manusia, utas dalam konkurensi non-paralel tampaknya berjalan pada saat yang sama tetapi pada kenyataannya tidak. Dalam thread konkurensi non-paralel dengan cepat beralih dan bergiliran untuk menggunakan prosesor melalui slicing waktu. Sementara dalam paralelisme ada beberapa prosesor yang tersedia, beberapa utas dapat berjalan pada prosesor yang berbeda secara bersamaan.

Referensi: Pengantar Konkurensi dalam Bahasa Pemrograman

Paralelisme adalah eksekusi proses secara simultan pada multiple cores per CPUatau multiple CPUs (on a single motherboard).

Konkurensi adalah saat Paralelisme dicapai pada single core/CPUdengan menggunakan algoritma penjadwalan yang membagi waktu CPU (time-slice). Proses yang disisipkan .

Unit:

• 1 atau banyak core dalam satu CPU (hampir semua prosesor modern)
• 1 atau banyak CPU pada motherboard (pikirkan server sekolah lama)
• 1 aplikasi adalah 1 program (pikirkan browser Chrome)
• 1 program dapat memiliki 1 atau banyak proses (anggap setiap tab browser Chrome adalah suatu proses)
• 1 proses dapat memiliki 1 atau banyak utas dari 1 program (tab Chrome memutar video Youtube dalam 1 utas, utas lain memunculkan bagian komentar, lainnya untuk info masuk pengguna)
• Dengan demikian, 1 program dapat memiliki 1 atau banyak utas eksekusi
• 1 proses adalah thread(s)+allocated memory resources by OS (heap, register, stack, memori kelas)

Concurrency => Ketika beberapa tugas dilakukan dalam periode waktu yang tumpang tindih dengan sumber daya bersama (berpotensi memaksimalkan pemanfaatan sumber daya).

Paralel => ketika satu tugas dibagi menjadi beberapa sub-tugas independen sederhana yang dapat dilakukan secara bersamaan.

Anggap saja sebagai layanan antrian di mana server hanya dapat melayani pekerjaan pertama dalam antrian.

1 server, 1 pekerjaan antrian (dengan 5 pekerjaan) -> tidak ada konkurensi, tidak ada paralelisme (Hanya satu pekerjaan yang dilayani hingga selesai, pekerjaan berikutnya dalam antrian harus menunggu sampai pekerjaan yang dilayani selesai dan tidak ada server lain untuk layani)

1 server, 2 atau lebih antrian yang berbeda (dengan 5 pekerjaan per antrian) -> konkurensi (karena server berbagi waktu dengan semua pekerjaan pertama dalam antrian, sama atau berbobot), masih tidak ada paralelisme karena setiap saat, hanya ada satu dan satu-satunya pekerjaan sedang dilayani.

2 atau lebih server, satu Antrian -> paralelisme (2 pekerjaan dilakukan pada saat yang sama) tetapi tidak ada konkurensi (server tidak berbagi waktu, pekerjaan ke-3 harus menunggu sampai salah satu server selesai.)

2 atau lebih server, 2 atau lebih antrian berbeda -> konkurensi dan paralelisme

Dengan kata lain, concurrency membagi waktu untuk menyelesaikan suatu pekerjaan, itu MUNGKIN mengambil waktu yang sama untuk menyelesaikan pekerjaannya, tetapi setidaknya memulai lebih awal. Yang penting adalah, pekerjaan dapat diiris menjadi pekerjaan yang lebih kecil, yang memungkinkan interleaving.

Paralelisme dicapai dengan lebih banyak CPU, server, orang, dll yang berjalan secara paralel.

Perlu diingat, jika sumber daya dibagikan, paralelisme murni tidak dapat dicapai, tetapi di sinilah concurrency akan memiliki penggunaan praktis terbaik, mengambil pekerjaan lain yang tidak membutuhkan sumber daya itu.

Saya akan menawarkan jawaban yang sedikit bertentangan dengan beberapa jawaban populer di sini. Menurut pendapat saya, konkurensi adalah istilah umum yang mencakup paralelisme. Concurrency berlaku untuk situasi apa pun di mana tugas atau unit kerja yang berbeda tumpang tindih dalam waktu. Paralelisme berlaku lebih khusus untuk situasi di mana unit kerja yang berbeda dievaluasi / dieksekusi pada waktu fisik yang sama. Landasan dari paralelisme adalah mempercepat perangkat lunak yang dapat mengambil manfaat dari berbagai sumber daya komputasi fisik. Konsep utama lainnya yang sesuai dengan konkurensi adalah interaktivitas. Interaktivitasberlaku ketika tumpang tindih tugas dapat diamati dari dunia luar. Alasan utama interaktivitas adalah membuat perangkat lunak yang responsif terhadap entitas dunia nyata seperti pengguna, rekan jaringan, periferal perangkat keras, dll.

Paralelisme dan interaktivitas hampir seluruhnya merupakan dimensi independen dari konkurensi. Untuk proyek tertentu pengembang mungkin peduli, baik atau tidak sama sekali. Mereka cenderung untuk berselisih, paling tidak karena kekejian yaitu utas memberikan primitif yang cukup nyaman untuk melakukan keduanya.

Sedikit lebih detail tentang paralelisme :

Paralelisme ada pada skala yang sangat kecil (misalnya paralelisme tingkat instruksi dalam prosesor), skala menengah (misalnya prosesor multicore) dan skala besar (misalnya cluster komputasi berkinerja tinggi). Tekanan pada pengembang perangkat lunak untuk mengekspos lebih banyak paralelisme tingkat-benang telah meningkat dalam beberapa tahun terakhir, karena pertumbuhan prosesor multicore. Paralelisme terkait erat dengan gagasan ketergantungan . Ketergantungan membatasi sejauh mana paralelisme dapat dicapai; dua tugas tidak dapat dieksekusi secara paralel jika satu bergantung pada yang lain (Mengabaikan spekulasi).

Ada banyak pola dan kerangka kerja yang digunakan programmer untuk mengekspresikan paralelisme: jalur pipa, kumpulan tugas, operasi agregat pada struktur data ("array paralel").

Sedikit lebih detail tentang interaktivitas :

Cara paling dasar dan umum untuk melakukan interaktivitas adalah dengan peristiwa (yaitu perulangan acara dan penangan / panggilan balik). Untuk tugas-tugas sederhana, kejadiannya sangat bagus. Mencoba melakukan tugas yang lebih kompleks dengan peristiwa masuk ke tumpukan ripping (alias panggilan balik; alias kontrol inversi). Ketika Anda muak dengan acara Anda dapat mencoba hal-hal yang lebih eksotis seperti generator, coroutine (alias Async / Menunggu), atau utas kooperatif.

Demi kecakapan perangkat lunak yang andal, jangan gunakan utas jika yang Anda tuju adalah interaktivitas.

Keramahan

Saya tidak suka slogan "konkurensi Rob Pike bukan paralelisme; lebih baik" slogan. Konkurensi tidak lebih baik atau lebih buruk daripada paralelisme. Konkurensi mencakup interaktivitas yang tidak dapat dibandingkan dengan cara paralelisme yang lebih baik / lebih buruk. Ini seperti mengatakan "aliran kontrol lebih baik daripada data".

Dalam elektronik, serial dan paralel mewakili jenis topologi statis, menentukan perilaku aktual rangkaian. Ketika tidak ada konkurensi, paralelisme menjadi deterministik .

Untuk menggambarkan fenomena yang dinamis dan terkait waktu , kami menggunakan istilah sekuensial dan bersamaan . Misalnya, hasil tertentu dapat diperoleh melalui urutan tugas tertentu (misalnya resep). Ketika kita berbicara dengan seseorang, kita menghasilkan urutan kata-kata. Namun, pada kenyataannya, banyak proses lain terjadi pada saat yang sama, dan karenanya, menyetujui hasil aktual dari tindakan tertentu. Jika banyak orang berbicara pada saat yang sama, pembicaraan bersamaan dapat mengganggu urutan kami, tetapi hasil dari gangguan ini tidak diketahui sebelumnya. Concurrency memperkenalkan ketidakpastian .

Karakterisasi serial / paralel dan sekuensial / konkuren adalah ortogonal. Contohnya adalah komunikasi digital. Dalam adaptor serial , pesan digital sementara (mis. Berurutan ) didistribusikan di sepanjang jalur komunikasi yang sama (mis. Satu kabel). Dalam adaptor paralel , ini dibagi juga pada jalur komunikasi paralel (mis. Banyak kabel), dan kemudian direkonstruksi di sisi penerima.

Mari kita gambar permainan, dengan 9 anak. Jika kita membuangnya sebagai rantai, memberikan pesan pada awalnya dan menerimanya di akhir, kita akan memiliki komunikasi serial. Lebih banyak kata yang menyusun pesan, yang terdiri atas urutan kesatuan komunikasi.

I like ice-cream so much. > X > X > X > X > X > X > X > X > X > ....

Ini adalah proses berurutan yang direproduksi pada infrastruktur serial .

Sekarang, mari kita bayangkan untuk membagi anak-anak menjadi kelompok-kelompok 3. Kita membagi frasa menjadi tiga bagian, memberikan yang pertama kepada anak dari garis di sebelah kiri kita, yang kedua ke anak dari garis tengah, dll.

I like ice-cream so much. > I like    > X > X > X > .... > ....
                          > ice-cream > X > X > X > ....
                          > so much   > X > X > X > ....

Ini adalah proses berurutan yang direproduksi pada infrastruktur paralel (meskipun sebagian serial).

Dalam kedua kasus, seandainya ada komunikasi yang sempurna antara anak-anak, hasilnya ditentukan terlebih dahulu.

Jika ada orang lain yang berbicara dengan anak pertama pada saat yang sama dengan Anda, maka kami akan memiliki proses bersamaan . Kami tidak tahu proses mana yang akan dipertimbangkan oleh infrastruktur, sehingga hasil akhirnya tidak ditentukan sebelumnya.

Konkurensi adalah bentuk paralelisme umum. Misalnya program paralel juga bisa disebut bersamaan tetapi sebaliknya tidak benar.

1. Eksekusi bersamaan dimungkinkan pada prosesor tunggal (beberapa utas, dikelola oleh penjadwal atau kumpulan benang)

2. Eksekusi paralel tidak dimungkinkan pada prosesor tunggal tetapi pada beberapa prosesor. (Satu proses per prosesor)

3. Komputasi terdistribusi juga merupakan topik terkait dan itu juga bisa disebut komputasi bersamaan tetapi sebaliknya tidak benar, seperti paralelisme.

Untuk detail bacalah makalah penelitian ini Concepts of Concurrent Programming

Saya sangat menyukai representasi grafis ini dari jawaban lain - saya pikir ini menjawab pertanyaan jauh lebih baik daripada banyak jawaban di atas

Paralelisme vs Konkurensi Ketika dua utas berjalan secara paralel, keduanya berjalan pada saat yang sama. Misalnya, jika kita memiliki dua utas, A dan B, maka eksekusi paralelnya akan terlihat seperti ini:

CPU 1: A ------------------------->

CPU 2: B ------------------------->

Ketika dua utas berjalan bersamaan, eksekusi mereka tumpang tindih. Tumpang tindih dapat terjadi dalam salah satu dari dua cara: thread dijalankan pada saat yang sama (yaitu secara paralel, seperti di atas), atau eksekusi mereka sedang disisipkan pada prosesor, seperti:

CPU 1: A -----------> B ----------> A -----------> B -------- ->

Jadi, untuk tujuan kita, paralelisme dapat dianggap sebagai kasus konkurensi khusus

Sumber: Jawaban lain di sini

Semoga itu bisa membantu.

Saya sangat suka jawaban Paul Butcher untuk pertanyaan ini (dia adalah penulis Seven Concurrency Models dalam Seven Weeks ):

Meskipun mereka sering bingung, paralelisme dan konkurensi adalah hal yang berbeda. Konkurensi adalah aspek dari domain masalah — kode Anda perlu menangani beberapa peristiwa simultan (atau hampir simultan) . Paralelisme, sebaliknya, adalah aspek dari domain solusi — Anda ingin membuat program Anda berjalan lebih cepat dengan memproses bagian-bagian berbeda dari masalah secara paralel. Beberapa pendekatan berlaku untuk konkurensi, beberapa untuk paralelisme, dan beberapa untuk keduanya. Pahami yang Anda hadapi dan pilih alat yang tepat untuk pekerjaan itu.

Konkurensi dapat melibatkan tugas yang dijalankan secara bersamaan atau tidak (mereka memang dapat dijalankan dalam prosesor / inti yang terpisah tetapi mereka juga dapat dijalankan dalam "ticks"). Yang penting adalah bahwa konkurensi selalu merujuk pada melakukan bagian dari satu tugas yang lebih besar . Jadi pada dasarnya ini adalah bagian dari beberapa perhitungan. Anda harus pintar tentang apa yang dapat Anda lakukan secara bersamaan dan apa yang tidak dan bagaimana menyinkronkan.

Paralelisme berarti bahwa Anda hanya melakukan beberapa hal secara bersamaan. Mereka tidak perlu menjadi bagian dari penyelesaian satu masalah. Utas Anda, misalnya, masing-masing dapat memecahkan satu masalah. Tentu saja hal-hal sinkronisasi juga berlaku tetapi dari perspektif yang berbeda.

"Konkurensi" adalah ketika ada banyak hal yang sedang berlangsung .

"Paralelisme" adalah ketika hal-hal bersamaan mengalami kemajuan pada saat yang bersamaan .

Contoh konkurensi tanpa paralelisme:

• Beberapa utas pada satu inti.
• Beberapa pesan dalam antrian pesan Win32.
• Beberapa SqlDataReaders pada koneksi MARS .
• Beberapa janji JavaScript di tab browser.

Perhatikan, bagaimanapun, bahwa perbedaan antara konkurensi dan paralelisme seringkali merupakan masalah perspektif. Contoh di atas adalah non-paralel dari perspektif (efek yang dapat diamati) dari mengeksekusi kode Anda. Tetapi ada paralelisme tingkat instruksi bahkan dalam satu inti. Ada beberapa perangkat keras yang melakukan hal-hal yang paralel dengan CPU dan kemudian menginterupsi CPU setelah selesai. GPU bisa menjadi gambar saat Anda melakukan prosedur window atau event handler sedang dijalankan. DBMS mungkin melintasi B-Trees untuk kueri berikutnya saat Anda masih mengambil hasil dari yang sebelumnya. Browser dapat melakukan tata letak atau jaringan saat Anda Promise.resolve()sedang dieksekusi. Dll, dll ...

Jadi begitulah. Dunia berantakan seperti biasa;)

Cara paling sederhana dan paling elegan untuk memahami keduanya menurut saya adalah ini. Konkurensi memungkinkan interleaving eksekusi dan dapat memberikan ilusi paralelisme. Ini berarti bahwa sistem bersamaan dapat menjalankan video Youtube Anda di samping Anda menulis dokumen di Word, misalnya. OS yang mendasarinya, menjadi sistem konkuren, memungkinkan tugas-tugas itu untuk interleave eksekusi mereka. Karena komputer menjalankan instruksi dengan begitu cepat, ini memberikan penampilan melakukan dua hal sekaligus.

Paralelisme adalah ketika hal-hal seperti itu benar - benar sejajar. Dalam contoh di atas, Anda mungkin menemukan kode pemrosesan video dijalankan pada satu inti, dan aplikasi Word sedang berjalan pada yang lain. Perhatikan bahwa ini berarti bahwa program bersamaan juga bisa paralel! Penataan aplikasi Anda dengan utas dan proses memungkinkan program Anda untuk mengeksploitasi perangkat keras yang mendasarinya dan berpotensi dilakukan secara paralel.

Mengapa tidak semuanya paralel? Salah satu alasannya adalah karena konkurensi adalah cara menyusun program dan merupakan keputusan desain untuk memfasilitasi pemisahan kekhawatiran, sedangkan paralelisme sering digunakan atas nama kinerja. Lain adalah bahwa beberapa hal secara fundamental tidak dapat sepenuhnya dilakukan secara paralel. Contohnya adalah menambahkan dua hal ke bagian belakang antrian - Anda tidak dapat memasukkan keduanya sekaligus. Sesuatu harus pergi dulu dan yang lain di belakangnya, atau Anda mengacaukan antrian. Meskipun kami dapat melakukan interleave eksekusi seperti itu (sehingga kami mendapatkan antrian bersamaan), Anda tidak dapat melakukannya secara paralel.

Semoga ini membantu!

Pemrograman bersamaan menganggap operasi yang tampaknya tumpang tindih dan terutama berkaitan dengan kompleksitas yang muncul karena aliran kontrol non-deterministik. Biaya kuantitatif yang terkait dengan program bersamaan biasanya throughput dan latensi. Program konkuren seringkali terikat IO tetapi tidak selalu, mis. Pengumpul sampah konkuren sepenuhnya menggunakan CPU. Contoh pedagogis dari program bersamaan adalah perayap web. Program ini memulai permintaan untuk halaman web dan menerima tanggapan secara bersamaan ketika hasil unduhan menjadi tersedia, mengumpulkan satu set halaman yang telah dikunjungi. Aliran kontrol bersifat non-deterministik karena responsnya tidak harus diterima dalam urutan yang sama setiap kali program dijalankan. Karakteristik ini dapat membuatnya sangat sulit untuk men-debug program bersamaan. Beberapa aplikasi berbarengan secara fundamental, misalnya server web harus menangani koneksi klien secara bersamaan. Erlang mungkin bahasa mendatang yang paling menjanjikan untuk pemrograman yang sangat bersamaan.

Pemrograman paralel menyangkut operasi yang tumpang tindih untuk tujuan spesifik meningkatkan throughput. Kesulitan pemrograman bersamaan dihindari dengan membuat aliran kendali menjadi deterministik. Biasanya, program menelurkan set tugas anak yang berjalan secara paralel dan tugas induk hanya berlanjut setelah setiap subtugas selesai. Ini membuat program paralel lebih mudah di-debug. Bagian sulit dari pemrograman paralel adalah optimalisasi kinerja sehubungan dengan masalah seperti granularity dan komunikasi. Yang terakhir masih menjadi masalah dalam konteks multicores karena ada biaya yang cukup besar terkait dengan mentransfer data dari satu cache ke yang lain. Multiply matrix-matrix multiply adalah contoh pedagogis pemrograman paralel dan dapat diselesaikan secara efisien dengan menggunakan Straasen ' s divide-and-conquer algoritme dan serang sub-masalah secara paralel. Cilk mungkin merupakan bahasa yang paling menjanjikan untuk pemrograman paralel berkinerja tinggi pada komputer memori bersama (termasuk multicores).

Disalin dari jawaban saya: https://stackoverflow.com/a/3982782

Paralelisme: Memiliki banyak utas melakukan tugas serupa yang independen satu sama lain dalam hal data dan sumber daya yang mereka perlukan untuk melakukannya. Misalnya: Perayap Google dapat menelurkan ribuan utas dan setiap utas dapat melakukan tugasnya secara mandiri.

Concurrency: Concurrency muncul ketika Anda telah berbagi data, sumber daya bersama di antara utas. Dalam sistem transaksional ini berarti Anda harus menyinkronkan bagian penting dari kode menggunakan beberapa teknik seperti Kunci, semaphores, dll.

(Saya cukup terkejut pertanyaan mendasar seperti itu tidak diselesaikan dengan benar dan rapi selama bertahun-tahun ...)

Singkatnya, baik konkurensi maupun paralelisme adalah sifat-sifat komputasi .

Sebagai perbedaannya, inilah penjelasan dari Robert Harper :

Hal pertama yang harus dipahami adalah paralelisme tidak ada hubungannya dengan konkurensi . Concurrency berkaitan dengan komposisi program yang tidak ditentukan (atau komponennya). Paralelisme berkaitan dengan efisiensi asimtotik program dengan perilaku deterministik . Concurrency adalah semua tentang mengelola hal yang tidak dapat dikelola: peristiwa tiba dengan alasan di luar kendali kami, dan kami harus meresponsnya. Seorang pengguna mengklik mouse, manajer jendela harus merespons, meskipun tampilan menuntut perhatian. Situasi seperti itu pada dasarnya tidak deterministik, tetapi kami juga menggunakan pro formanondeterminisme dalam pengaturan deterministik dengan berpura-pura bahwa komponen menandakan peristiwa dalam urutan yang sewenang-wenang, dan bahwa kita harus menanggapinya ketika mereka muncul. Komposisi nondeterministik adalah ide penataan program yang kuat. Paralelisme, di sisi lain, adalah semua tentang dependensi di antara subkomputasi dari perhitungan deterministik. Hasilnya tidak diragukan, tetapi ada banyak cara untuk mencapainya, beberapa lebih efisien daripada yang lain. Kami ingin memanfaatkan peluang itu untuk keuntungan kami.

Mereka dapat berupa sifat ortogonal dalam program. Baca posting blog ini untuk ilustrasi tambahan. Dan yang satu ini membahas sedikit lebih banyak tentang perbedaan komponen dalam pemrograman , seperti utas.

Perhatikan bahwa threading atau multitasking adalah semua implementasi komputasi yang melayani tujuan yang lebih konkret. Mereka dapat dikaitkan dengan paralelisme dan konkurensi, tetapi tidak dengan cara yang esensial. Dengan demikian mereka bukanlah entri yang bagus untuk memulai penjelasan.

Satu lagi sorotan: "waktu" fisik (hampir tidak ada hubungannya dengan properti yang dibahas di sini). Waktu hanyalah cara implementasi pengukuran untuk menunjukkan signifikansi properti, tetapi jauh dari esensi. Pikirkan dua kali peran "waktu" dalam kompleksitas waktu - yang kurang lebih serupa, bahkan pengukurannya seringkali lebih signifikan dalam kasus itu.

"Bersamaan" adalah melakukan sesuatu - apa saja - pada saat yang bersamaan. Bisa jadi hal yang berbeda, atau hal yang sama. Terlepas dari jawaban yang diterima, yang kurang, ini bukan tentang "muncul pada saat yang sama." Benar-benar di saat yang bersamaan. Anda memerlukan beberapa inti CPU, baik menggunakan memori bersama dalam satu host, atau memori terdistribusi pada host yang berbeda, untuk menjalankan kode bersamaan. Pipa dari 3 tugas berbeda yang secara bersamaan berjalan pada saat yang sama adalah contohnya: Tugas-tingkat-2 harus menunggu unit diselesaikan oleh tugas-tingkat-1, dan tugas-tingkat-3 harus menunggu unit pekerjaan diselesaikan oleh tingkat tugas-2. Contoh lain adalah konkurensi 1-produsen dengan 1-konsumen; atau banyak produsen dan 1 konsumen; pembaca dan penulis; et al.

"Paralel" adalah melakukan hal yang sama pada saat yang bersamaan. Ini bersamaan, tetapi lebih jauh lagi itu adalah perilaku yang sama terjadi pada waktu yang sama, dan paling khas pada data yang berbeda. Aljabar matriks sering dapat diparalelkan, karena Anda memiliki operasi yang sama berjalan berulang kali: Misalnya jumlah kolom dari suatu matriks semua dapat dihitung pada saat yang sama menggunakan perilaku (jumlah) yang sama tetapi pada kolom yang berbeda. Merupakan strategi umum untuk mempartisi (memisahkan) kolom di antara inti prosesor yang tersedia, sehingga Anda memiliki jumlah pekerjaan yang hampir sama (jumlah kolom) yang ditangani oleh masing-masing inti prosesor. Cara lain untuk memisahkan pekerjaan adalah tugas-tugas di mana pekerja yang menyelesaikan pekerjaannya kembali ke manajer yang membagikan pekerjaan dan mendapatkan lebih banyak pekerjaan secara dinamis sampai semuanya selesai. Algoritma ticketing adalah hal lain.

Bukan hanya kode numerik yang dapat diparalelkan. File terlalu sering dapat diproses secara paralel. Dalam aplikasi pemrosesan bahasa alami, untuk masing-masing dari jutaan file dokumen, Anda mungkin perlu menghitung jumlah token dalam dokumen. Ini paralel, karena Anda menghitung token, yang merupakan perilaku yang sama, untuk setiap file.

Dengan kata lain, paralelisme adalah ketika perilaku yang sama dilakukan secara bersamaan. Bersamaan berarti pada saat yang sama, tetapi belum tentu perilaku yang sama. Paralel adalah jenis konkurensi tertentu di mana hal yang sama terjadi pada waktu yang bersamaan.

Istilah misalnya akan mencakup instruksi atom, bagian kritis, pengecualian bersama, spin-waiting, semaphores, monitor, hambatan, pesan-lewat, pengurangan peta, detak jantung, cincin, algoritma tiket, utas, MPI, OpenMP.

Karya Gregory Andrews adalah buku teks teratas: Multithreaded, Parallel, and Distributed Programming.

Hebat, izinkan saya mengambil skenario untuk menunjukkan apa yang saya mengerti. misalkan ada 3 anak bernama: A, B, C. A dan B bicara, C dengarkan. Untuk A dan B, mereka paralel: A: Saya A. B: Saya B.

Tapi untuk C, otaknya harus mengambil proses bersamaan untuk mendengarkan A dan B, mungkin: Aku IA. B.

Concurrency sederhana berarti lebih dari satu tugas berjalan (tidak perlu secara paralel). Sebagai contoh, kami memiliki 3 tugas, maka pada setiap saat waktu: lebih dari satu dapat berjalan atau semua dapat berjalan pada waktu yang sama.

Paralelisme berarti mereka benar-benar berjalan secara paralel. Jadi dalam hal ini ketiganya harus berjalan pada saat yang sama.

Gagasan Pike tentang "konkurensi" adalah desain yang disengaja dan keputusan implementasi. Desain program yang mampu secara bersamaan dapat atau tidak menunjukkan "paralelisme" perilaku; itu tergantung pada lingkungan runtime.

Anda tidak ingin paralelisme dipamerkan oleh program yang tidak dirancang untuk konkurensi. :-) Tetapi sejauh itu merupakan keuntungan bersih untuk faktor-faktor yang relevan (konsumsi daya, kinerja, dll.), Anda menginginkan desain yang bersamaan secara maksimal sehingga sistem host dapat memparalelasikan pelaksanaannya jika memungkinkan.

Bahasa pemrograman Pike's Go menggambarkan hal ini secara ekstrem: fungsinya adalah semua utas yang dapat berjalan dengan benar secara bersamaan, yaitu memanggil fungsi selalu membuat utas yang akan berjalan secara paralel dengan penelepon jika sistem mampu melakukannya. Aplikasi dengan ratusan atau bahkan ribuan utas sangat biasa di dunianya. (Saya bukan ahli Go, itu hanya pendapat saya.)