Apa perbedaan antara pemrograman bersamaan dan pemrograman paralel?

Apa perbedaan antara pemrograman bersamaan dan pemrograman paralel? Saya bertanya kepada google tetapi tidak menemukan apa pun yang membantu saya memahami perbedaan itu. Bisakah Anda memberi saya contoh untuk keduanya?

Untuk saat ini saya menemukan penjelasan ini: http://www.linux-mag.com/id/7411 - tetapi "concurrency adalah properti dari program" vs "eksekusi paralel adalah properti dari mesin" tidak cukup bagi saya - masih saya tidak bisa mengatakan apa itu apa.

Jika program Anda menggunakan utas (pemrograman bersamaan), itu tidak harus dijalankan seperti itu (eksekusi paralel), karena tergantung pada apakah mesin dapat menangani beberapa utas.

Ini contoh visualnya. Utas pada mesin non-utas :

        --  --  --
     /              \
>---- --  --  --  -- ---->>

Thread pada mesin berulir :

     ------
    /      \
>-------------->>

Tanda hubung mewakili kode yang dieksekusi. Seperti yang Anda lihat, mereka berdua berpisah dan mengeksekusi secara terpisah, tetapi mesin berulir dapat mengeksekusi beberapa bagian terpisah sekaligus.

Pemrograman bersamaanmenganggap 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.Erlang , alur kerja asinkron F # dan pustaka Akka Scala mungkin merupakan pendekatan yang paling menjanjikan untuk pemrograman yang sangat konkuren.

Pemrograman multicoreadalah kasus khusus pemrograman paralel. 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 untuk di-debug daripada program bersamaan. 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.Cilk mungkin merupakan pendekatan yang paling menjanjikan untuk pemrograman paralel berkinerja tinggi pada multicores dan telah diadopsi baik di Blok Bangunan Berulir Intel dan Perpustakaan Tugas Paralel Microsoft (dalam .NET 4).

https://joearms.github.io/published/2013-04-05-concurrent-and-parallel-programming.html

Bersamaan = Dua antrian dan satu mesin kopi.

Paralel = Dua antrian dan dua mesin kopi.

Menafsirkan pertanyaan asli sebagai komputasi paralel / konkuren alih-alih pemrograman .

Dalam perhitungan bersamaan dua perhitungan keduanya maju secara independen satu sama lain. Perhitungan kedua tidak harus menunggu sampai yang pertama selesai untuk maju. Namun itu tidak menyatakan, mekanisme bagaimana ini dicapai. Dalam pengaturan single-core, penangguhan dan pergantian antar utas diperlukan (juga disebut pre-emptive multithreading).

Dalam perhitungan paralel, dua perhitungan keduanya maju secara bersamaan - yang secara harfiah pada saat yang sama. Ini tidak dimungkinkan dengan CPU tunggal dan sebagai gantinya membutuhkan pengaturan multi-core.

Gambar dari artikel: "Paralel vs Bersamaan di Node.js"

melawan

Dalam pandangan dari prosesor, dapat dijelaskan oleh gambar ini

Dalam pandangan dari prosesor, dapat dijelaskan oleh gambar ini

Saya percaya pemrograman bersamaan mengacu pada pemrograman multithreaded yaitu membiarkan program Anda menjalankan banyak utas, disarikan dari perincian peranti keras.

Pemrograman paralel mengacu secara khusus merancang algoritma program Anda untuk memanfaatkan eksekusi paralel yang tersedia. Sebagai contoh, Anda dapat mengeksekusi secara paralel dua cabang dari beberapa algoritma dengan harapan bahwa itu akan mengenai hasil lebih cepat (rata-rata) daripada jika Anda pertama kali memeriksa yang pertama kemudian cabang kedua.

Saya menemukan konten ini di beberapa blog. Pikir itu berguna dan relevan.

Konkurensi dan paralelisme BUKAN hal yang sama. Dua tugas T1 dan T2 bersamaan jika urutan di mana dua tugas dieksekusi dalam waktu tidak ditentukan sebelumnya,

T1 dapat dieksekusi dan diselesaikan sebelum T2, T2 dapat dieksekusi dan diselesaikan sebelum T1, T1 dan T2 dapat dieksekusi secara bersamaan pada waktu yang sama (paralelisme), T1 dan T2 dapat dieksekusi secara alternatif, ... Jika dua utas bersamaan dijadwalkan oleh OS untuk dijalankan pada satu prosesor single-core non-SMT non-CMP, Anda mungkin mendapatkan konkurensi tetapi tidak paralelisme. Paralelisme dimungkinkan pada sistem multi-inti, multi-prosesor atau terdistribusi.

Konkurensi sering disebut sebagai properti suatu program, dan merupakan konsep yang lebih umum daripada paralelisme.

Sumber: https://blogs.oracle.com/yuanlin/entry/concurrency_vs_parallelism_concurrent_programming

Mereka adalah dua frasa yang menggambarkan hal yang sama dari (sangat sedikit) sudut pandang yang berbeda. Pemrograman paralel menggambarkan situasi dari sudut pandang perangkat keras - setidaknya ada dua prosesor (mungkin dalam satu paket fisik) yang bekerja pada masalah secara paralel. Pemrograman bersamaan menggambarkan hal-hal lebih dari sudut pandang perangkat lunak - dua atau lebih tindakan dapat terjadi pada waktu yang sama (bersamaan).

Masalahnya di sini adalah bahwa orang-orang mencoba menggunakan dua frasa untuk menarik perbedaan yang jelas ketika tidak ada yang benar-benar ada. Kenyataannya adalah bahwa garis pemisah yang mereka coba gambar telah kabur dan tidak jelas selama beberapa dekade, dan telah tumbuh semakin tidak jelas seiring waktu.

Apa yang mereka coba diskusikan adalah fakta bahwa pada suatu waktu, kebanyakan komputer hanya memiliki satu CPU. Ketika Anda menjalankan banyak proses (atau utas) pada CPU tunggal itu, CPU hanya benar-benar menjalankan satu instruksi dari salah satu utas tersebut sekaligus. Munculnya konkurensi adalah ilusi - pergantian CPU antara menjalankan instruksi dari utas yang berbeda cukup cepat dengan persepsi manusia (yang mana kurang dari 100 ms atau lebih terlihat seketika) sepertinya melakukan banyak hal sekaligus.

Kontras yang jelas untuk ini adalah komputer dengan banyak CPU, atau CPU dengan banyak inti, sehingga mesin menjalankan instruksi dari banyak utas dan / atau proses pada waktu yang bersamaan; mengeksekusi kode yang satu tidak bisa / tidak memiliki efek pada mengeksekusi kode yang lain.

Sekarang masalahnya: perbedaan bersih seperti itu hampir tidak pernah ada. Desainer komputer sebenarnya cukup cerdas, sehingga mereka memperhatikan sejak lama bahwa (misalnya) ketika Anda perlu membaca beberapa data dari perangkat I / O seperti disk, butuh waktu lama (dalam hal siklus CPU) untuk selesai. Alih-alih membiarkan CPU menganggur saat itu terjadi, mereka menemukan berbagai cara untuk membiarkan satu proses / utas membuat permintaan I / O, dan membiarkan kode dari beberapa proses / utas lain dijalankan pada CPU sementara permintaan I / O selesai.

Jadi, jauh sebelum CPU multi-core menjadi norma, kami memiliki operasi dari banyak utas yang terjadi secara paralel.

Itu hanya puncak gunung es sekalipun. Beberapa dekade yang lalu, komputer juga mulai menyediakan level paralelisme lain. Sekali lagi, sebagai orang yang cukup cerdas, perancang komputer memperhatikan bahwa dalam banyak kasus, mereka memiliki instruksi yang tidak saling mempengaruhi, sehingga dimungkinkan untuk menjalankan lebih dari satu instruksi dari aliran yang sama pada saat yang bersamaan. Salah satu contoh awal yang menjadi cukup terkenal adalah Data Kontrol 6600. Ini (dengan margin yang cukup lebar) komputer tercepat di dunia ketika diperkenalkan pada tahun 1964 - dan banyak arsitektur dasar yang sama tetap digunakan sampai sekarang. Ini melacak sumber daya yang digunakan oleh setiap instruksi, dan memiliki satu set unit eksekusi yang mengeksekusi instruksi segera setelah sumber daya yang mereka andalkan menjadi tersedia, sangat mirip dengan desain prosesor Intel / AMD terbaru.

Tapi (seperti yang sering dikatakan iklan) tunggu - itu belum semuanya. Masih ada elemen desain lain untuk menambah kebingungan lebih lanjut. Sudah diberi beberapa nama yang berbeda (misalnya, "Hyperthreading", "SMT", "CMP"), tetapi mereka semua merujuk pada ide dasar yang sama: CPU yang dapat mengeksekusi banyak utas secara bersamaan, menggunakan kombinasi beberapa sumber daya yang independen untuk setiap utas, dan beberapa sumber daya yang dibagi di antara utas. Dalam kasus khusus ini dikombinasikan dengan paralelisme tingkat instruksi yang diuraikan di atas. Untuk melakukan itu, kami memiliki dua (atau lebih) set register arsitektur. Kemudian kami memiliki satu set unit eksekusi yang dapat menjalankan instruksi segera setelah sumber daya yang diperlukan tersedia.

Kemudian, tentu saja, kita sampai pada sistem modern dengan banyak inti. Di sini segalanya sudah jelas, bukan? Kami memiliki N (di suatu tempat antara 2 dan 256 atau lebih, pada saat ini) core yang terpisah, yang semuanya dapat menjalankan instruksi pada saat yang sama, jadi kami memiliki kasus paralelisme nyata yang jelas - mengeksekusi instruksi dalam satu proses / thread tidak t mempengaruhi pelaksanaan instruksi di tempat lain.

Yah, semacam itu. Bahkan di sini kita memiliki beberapa sumber daya independen (register, unit eksekusi, setidaknya satu tingkat cache) dan beberapa sumber daya bersama (biasanya setidaknya tingkat cache terendah, dan tentunya pengontrol memori dan bandwidth ke memori).

Untuk meringkas: skenario sederhana yang orang suka kontras antara sumber daya bersama dan sumber daya independen hampir tidak pernah terjadi dalam kehidupan nyata. Dengan semua sumber daya dibagikan, kita berakhir dengan sesuatu seperti MS-DOS, di mana kita hanya dapat menjalankan satu program pada satu waktu, dan kita harus berhenti menjalankan satu sebelum kita dapat menjalankan yang lain sama sekali. Dengan sumber daya yang sepenuhnya independen, kami memiliki N komputer yang menjalankan MS-DOS (bahkan tanpa jaringan untuk menghubungkan mereka) tanpa kemampuan untuk berbagi apa pun di antara mereka sama sekali (karena jika kami bahkan dapat berbagi file, well, itu adalah sumber daya bersama, sebuah pelanggaran terhadap premis dasar tentang tidak ada yang dibagikan).

Setiap kasus yang menarik melibatkan beberapa kombinasi sumber daya independen dan sumber daya bersama. Setiap komputer yang cukup modern (dan banyak yang sama sekali tidak modern) memiliki setidaknya beberapa kemampuan untuk melakukan setidaknya beberapa operasi independen secara bersamaan, dan hampir semua hal yang lebih canggih daripada MS-DOS telah memanfaatkannya untuk setidaknya beberapa derajat.

Pembagian yang bagus dan bersih antara "bersamaan" dan "paralel" yang orang suka menggambar tidak ada, dan hampir tidak pernah ada. Apa yang orang suka klasifikasikan sebagai "bersamaan" biasanya masih melibatkan paling tidak satu dan lebih banyak jenis eksekusi paralel. Apa yang mereka suka diklasifikasikan sebagai "paralel" sering melibatkan berbagi sumber daya dan (misalnya) satu proses memblokir eksekusi yang lain saat menggunakan sumber daya yang dibagi di antara keduanya.

Orang-orang yang mencoba menggambar perbedaan bersih antara "paralel" dan "bersamaan" hidup dalam fantasi komputer yang tidak pernah benar-benar ada.

• Concurrent programmingsecara umum mengacu pada lingkungan di mana tugas yang kita tetapkan dapat terjadi dalam urutan apa pun. Satu tugas dapat terjadi sebelum atau sesudah yang lain, dan beberapa atau semua tugas dapat dilakukan pada saat yang sama.

• Parallel programmingadalah untuk secara khusus merujuk pada pelaksanaan simultan tugas bersamaan pada prosesor yang berbeda. Dengan demikian, semua pemrograman paralel adalah bersamaan, tetapi tidak semua pemrograman bersamaan adalah paralel.

Sumber: Pemrograman PThreads - Standar POSIX untuk Multiprocessing yang Lebih Baik, Buttlar, Farrell, Nichols

Dalam pemrograman, konkurensi adalah komposisi dari proses yang dieksekusi secara independen, sedangkan paralelisme adalah eksekusi simultan dari komputasi (kemungkinan terkait).
- Andrew Gerrand -

Dan

Concurrency adalah komposisi dari komputasi yang dieksekusi secara independen. Concurrency adalah cara untuk menyusun perangkat lunak, terutama sebagai cara untuk menulis kode bersih yang berinteraksi dengan dunia nyata. Ini bukan paralelisme.

Konkurensi bukanlah paralelisme, meskipun memungkinkan paralelisme. Jika Anda hanya memiliki satu prosesor, program Anda masih bisa bersamaan tetapi tidak bisa paralel. Di sisi lain, program konkuren yang ditulis dengan baik mungkin berjalan efisien secara paralel pada multiprosesor. Properti itu mungkin penting ...
- Rob Pike -

Untuk memahami perbedaannya, saya sangat merekomendasikan untuk melihat video Rob Pike (salah satu pencipta Golang) ini. Concurrency Bukan Paralelisme

Pemrograman paralel terjadi ketika kode dieksekusi pada waktu yang sama dan setiap eksekusi tidak tergantung pada yang lain. Oleh karena itu, biasanya tidak ada keasyikan tentang variabel bersama dan semacamnya karena itu tidak akan terjadi.

Namun, pemrograman konkuren terdiri dari kode yang dieksekusi oleh proses / utas berbeda yang berbagi variabel dan semacamnya, oleh karena itu pada pemrograman konkuren kita harus membuat semacam aturan untuk memutuskan proses / utas mana yang dijalankan terlebih dahulu, kita menginginkan ini sehingga kita dapat memastikan bahwa ada akan menjadi konsistensi dan bahwa kita dapat mengetahui dengan pasti apa yang akan terjadi. Jika tidak ada kontrol dan semua utas menghitung pada saat yang sama dan menyimpan hal-hal pada variabel yang sama, bagaimana kita tahu apa yang diharapkan pada akhirnya? Mungkin utas lebih cepat daripada yang lain, mungkin salah satu utas bahkan berhenti di tengah pelaksanaannya dan yang lain melanjutkan perhitungan yang berbeda dengan variabel yang rusak (belum sepenuhnya dihitung), kemungkinan tidak ada habisnya. Dalam situasi ini kita biasanya menggunakan pemrograman bersamaan bukan paralel.

Penjadwalan tugas klasik bisa serial , paralel atau bersamaan .

• Serial : tugas harus dieksekusi satu demi satu dalam urutan tipuan yang diketahui atau tidak akan berhasil. Cukup mudah.

• Paralel : tugas harus dijalankan pada saat yang sama atau tidak akan berfungsi.

  • Kegagalan tugas apa pun - secara fungsional atau dalam waktu - akan mengakibatkan kegagalan total sistem.
  • Semua tugas harus memiliki akal sehat yang dapat dipercaya.
    
    

  Cobalah untuk menghindari ini atau kita akan menangis saat minum teh.

• Bersamaan : kita tidak peduli. Kami tidak ceroboh: kami telah menganalisisnya dan itu tidak masalah; karena itu kami dapat menjalankan tugas apa pun menggunakan fasilitas apa pun yang tersedia kapan saja. Hari-hari bahagia.

Seringkali, penjadwalan yang tersedia berubah pada acara yang diketahui yang kami sebut perubahan negara.

Orang-orang sering berpikir ini adalah tentang perangkat lunak, tetapi sebenarnya konsep desain sistem yang pra-tanggal komputer; sistem perangkat lunak agak lambat dalam uptake, sangat sedikit bahasa perangkat lunak bahkan berusaha untuk mengatasi masalah tersebut. Anda dapat mencoba mencari bahasa transputer Occam jika Anda tertarik.

Singkatnya, desain sistem membahas hal-hal berikut:

• kata kerja - apa yang Anda lakukan (operasi atau algoritma)
• kata benda - apa yang Anda lakukan (data atau antarmuka)
• kapan - inisiasi, jadwal, perubahan status
• bagaimana - serial, paralel, bersamaan
• dimana - setelah Anda tahu kapan sesuatu terjadi, Anda bisa mengatakan di mana itu bisa terjadi dan bukan sebelumnya.
• mengapa - apakah ini cara untuk melakukannya? Adakah cara lain, dan yang lebih penting, cara yang lebih baik ? Apa yang terjadi jika Anda tidak melakukannya?

Semoga berhasil.

Saya mengerti perbedaannya:

1) Berjalan bersamaan secara bersamaan menggunakan sumber daya bersama 2) Berjalan paralel secara paralel menggunakan sumber daya yang berbeda

Jadi Anda dapat memiliki dua hal yang terjadi pada saat yang sama independen satu sama lain, bahkan jika mereka datang bersama pada poin (2) atau dua hal menggambar pada cadangan yang sama di seluruh operasi yang sedang dieksekusi (1).

Meskipun tidak ada kesepakatan lengkap tentang perbedaan antara istilah paralel dan konkuren , banyak penulis membuat perbedaan berikut:

• Dalam komputasi serentak, sebuah program adalah program di mana banyak tugas dapat berlangsung kapan saja.
• Dalam komputasi paralel, sebuah program adalah program di mana banyak tugas bekerja sama secara erat untuk memecahkan masalah.

Jadi program paralel bersamaan, tetapi program seperti sistem operasi multitasking juga bersamaan, bahkan ketika dijalankan pada mesin dengan hanya satu inti, karena beberapa tugas dapat sedang berlangsung kapan saja.

Sumber : Pengantar pemrograman paralel, Peter Pacheco

Sumber Konkurensi dan Paralelisme

Dalam proses multithreaded pada prosesor tunggal, prosesor dapat mengalihkan sumber daya eksekusi antara utas, menghasilkan eksekusi bersamaan .

Dalam proses multithread yang sama dalam lingkungan multiprosesor bersama-memori, setiap utas dalam proses dapat berjalan pada prosesor yang terpisah pada saat yang sama, menghasilkan eksekusi paralel .

Ketika proses memiliki thread yang lebih sedikit atau sebanyak yang ada pada prosesor, sistem pendukung thread bersamaan dengan lingkungan operasi memastikan bahwa setiap thread dijalankan pada prosesor yang berbeda.

Misalnya, dalam perkalian matriks yang memiliki jumlah utas dan prosesor yang sama, setiap utas (dan setiap prosesor) menghitung satu baris hasil.

Orang yang berbeda berbicara tentang berbagai jenis konkurensi dan paralelisme dalam banyak kasus spesifik yang berbeda, sehingga beberapa abstraksi untuk menutupi sifat umum mereka diperlukan.

Abstraksi dasar dilakukan dalam ilmu komputer, di mana konkurensi dan paralelisme dikaitkan dengan sifat-sifat program . Di sini, program adalah deskripsi formal dari komputasi. Program semacam itu tidak perlu dalam bahasa atau pengodean khusus apa pun, yang khusus untuk implementasi. Keberadaan API / ABI / ISA / OS tidak relevan dengan tingkat abstraksi seperti itu. Tentunya seseorang akan membutuhkan pengetahuan implementasi-spesifik yang lebih rinci (seperti model threading) untuk melakukan pekerjaan pemrograman konkret, semangat di balik abstraksi dasar tidak berubah.

Fakta penting kedua adalah, karena sifat umum, konkurensi , dan paralelisme dapat hidup berdampingan dalam banyak abstraksi yang berbeda .

Untuk perbedaan umum, lihat jawaban yang relevan untuk tampilan dasar konkurensi vs paralelisme. (Ada juga beberapa tautan yang mengandung beberapa sumber tambahan.)

Pemrograman bersamaan dan pemrograman paralel adalah teknik untuk mengimplementasikan sifat-sifat umum seperti itu dengan beberapa sistem yang mengekspos kemampuan program. Sistem biasanya bahasa pemrograman dan implementasinya.

Bahasa pemrograman dapat mengekspos properti yang dimaksud dengan aturan semantik bawaan. Dalam kebanyakan kasus, aturan tersebut menentukan evaluasi struktur bahasa tertentu (misalnya ekspresi) yang membuat komputasi terlibat secara bersamaan atau paralel. (Lebih khusus, efek komputasi yang tersirat oleh evaluasi dapat dengan sempurna mencerminkan sifat-sifat ini.) Namun, semantik bahasa paralel / paralel pada dasarnya kompleks dan tidak diperlukan untuk pekerjaan praktis (untuk mengimplementasikan algoritma konkuren / paralel yang efisien sebagai solusi dari masalah realistis. ). Jadi, sebagian besar bahasa tradisional mengambil pendekatan yang lebih konservatif dan lebih sederhana: dengan asumsi semantik evaluasi benar-benar berurutan dan berseri, kemudian memberikan primitif opsional untuk memungkinkan beberapaperhitungan yang bersamaan dan paralel. Primitif ini dapat berupa kata kunci atau konstruksi prosedural ("fungsi") yang didukung oleh bahasa. Mereka diimplementasikan berdasarkan interaksi dengan lingkungan yang dihosting (OS, atau "perangkat keras" logam antarmuka), biasanya buram (tidak dapat diturunkan menggunakan bahasa portable) ke bahasa. Jadi, dalam jenis abstraksi tingkat tinggi khusus yang dilihat oleh para programmer, tidak ada yang bersamaan / paralel selain primitif "ajaib" dan program yang mengandalkan primitif ini; para programmer kemudian dapat menikmati pengalaman pemrograman yang cenderung lebih sedikit kesalahan ketika properti konkurensi / paralelisme tidak begitu tertarik.

Meskipun primitif mengabstraksi kompleks dalam abstraksi tingkat paling tinggi, implementasinya masih memiliki kompleksitas ekstra yang tidak terekspos oleh fitur bahasa. Jadi, beberapa abstraksi tingkat menengah diperlukan. Salah satu contoh khas adalah threading . Threading memungkinkan satu atau lebih utas eksekusi (atau sekadar utas ; terkadang juga disebut proses , yang tidak harus konsep tugas yang dijadwalkan dalam OS) yang didukung oleh implementasi bahasa (runtime). Utas biasanya dijadwalkan sebelumnya oleh runtime, jadi utas tidak perlu tahu apa pun tentang utas lainnya. Dengan demikian, utas alami menerapkan paralelisme selama mereka tidak berbagi apa pun ( sumber daya kritis): cukup mendekomposisi perhitungan di utas yang berbeda, setelah implementasi yang mendasarinya memungkinkan tumpang tindih sumber daya komputasi selama eksekusi, ia bekerja. Utas juga tunduk pada akses bersamaan sumber daya bersama: hanya akses sumber daya dalam urutan apa pun memenuhi kendala minimal yang diperlukan oleh algoritma, dan implementasi pada akhirnya akan menentukan kapan harus mengakses. Dalam kasus seperti itu, beberapa operasi sinkronisasi mungkin diperlukan. Beberapa bahasa memperlakukan operasi threading dan sinkronisasi sebagai bagian dari abstraksi tingkat tinggi dan mengeksposnya sebagai primitif, sementara beberapa bahasa lain hanya mendorong primitif tingkat lebih tinggi (seperti futures / janji ).

Di bawah tingkat utas khusus-bahasa, ada multitasking dari lingkungan hosting yang mendasarinya (biasanya, OS). Multitasking preemptive OS-level digunakan untuk mengimplementasikan multithreading (preemptive). Di beberapa lingkungan seperti Windows NT, unit penjadwalan dasar (tugas) juga "utas". Untuk membedakannya dengan pengguna mengimplementasikan thread yang disebutkan di atas, mereka disebut thread kernel, di mana "kernel" berarti kernel dari OS _{(namun, secara tegas, ini tidak sepenuhnya benar untuk Windows NT; "real" kernel adalah NT eksekutif)} . Utas kernel tidak selalu dipetakan 1: 1 ke utas userspace, meskipun pemetaan 1: 1 sering mengurangi sebagian besar overhead pemetaan. Karena utas kernel adalah kelas berat (melibatkan panggilan sistem) untuk membuat / menghancurkan / berkomunikasi,utas hijau di ruang pengguna untuk mengatasi masalah overhead dengan biaya pemetaan overhead. Pilihan pemetaan tergantung pada paradigma pemrograman yang diharapkan dalam abstraksi tingkat tinggi. Misalnya, ketika sejumlah besar utas ruang pengguna diharapkan dieksekusi secara bersamaan (seperti Erlang ), pemetaan 1: 1 tidak pernah layak.

Yang mendasari multitasking OS adalah multitasking tingkat ISA yang disediakan oleh inti logis dari prosesor. Ini biasanya antarmuka publik tingkat paling rendah untuk programmer. Di bawah level ini, mungkin ada SMT . Ini adalah bentuk multithreading tingkat rendah yang diterapkan oleh perangkat keras, tetapi bisa dibilang, masih agak dapat diprogram - meskipun biasanya hanya dapat diakses oleh pabrik prosesor. Catatan desain perangkat keras tampaknya mencerminkan paralelisme, tetapi ada juga mekanisme penjadwalan bersamaan untuk membuat sumber daya perangkat keras internal digunakan secara efisien.

Dalam setiap tingkat "threading" yang disebutkan di atas, baik konkurensi dan paralelisme terlibat. Meskipun antarmuka pemrograman bervariasi secara dramatis, semuanya tunduk pada properti yang diungkapkan oleh abstraksi dasar di awal.

Cukup bagikan contoh yang membantu menyoroti perbedaan:

Pemrograman Paralel: Katakanlah Anda ingin menerapkan algoritma merge-sort . Setiap kali Anda membagi masalah menjadi dua sub-masalah, Anda dapat memiliki dua utas yang menyelesaikannya. Namun, untuk melakukan langkah penggabungan, Anda harus menunggu dua utas ini selesai karena penggabungan membutuhkan kedua sub-solusi. "Wajib Tunggu" ini menjadikan ini program paralel.

Program Bersamaan: Katakanlah Anda ingin mengompresi file teks dan menghasilkan file terkompresi untuk masing-masing file tersebut. Anda dapat memiliki dari 2 (hingga n) utas yang masing-masing menangani mengompres bagian dari file. Ketika setiap utas selesai, baru saja selesai, tidak perlu menunggu atau melakukan hal lain. Jadi, karena tugas yang berbeda dilakukan secara interleaved dalam "sembarang urutan" program ini bersamaan tetapi tidak paralel.

Seperti orang lain sebutkan, setiap program paralel adalah bersamaan (harus pada kenyataannya), tetapi tidak sebaliknya.

Saya akan mencoba menjelaskannya dengan gaya saya sendiri, mungkin tidak dalam istilah komputer tetapi memberi Anda ide umum.

Mari kita ambil contoh, katakanlah pekerjaan rumah tangga: membersihkan piring, membuang sampah, memotong rumput dll, juga kita memiliki 3 orang (utas) A, B, C untuk melakukannya

Bersamaan: Tiga individu memulai tugas yang berbeda yaitu,

A --> cleaning dishes
B --> taking out trash 
C --> mowing the lawn 

Di sini, urutan tugas tidak pasti dan responsnya tergantung pada jumlah pekerjaan

Paralel: Di sini jika kita ingin meningkatkan throughput, kita dapat menugaskan banyak orang untuk satu tugas, misalnya membersihkan piring, kita menugaskan dua orang, A menyabuni piring dan B mencuci piring yang mungkin meningkatkan throughput.

membersihkan piring:

A --> soaping the dishes
B --> washing the dishes

begitu seterusnya

Semoga ini memberi ide! sekarang pindah ke istilah teknis yang dijelaskan dalam jawaban lain;)