Computer Science BS Journal (CST334) : Week 5

   This week in CST334 our lectures covered: Concurrency and Threads, Threads API, Locks, and Lock-based data structure. In this learning journal I'll write and explanation/what I think to be the most important bits of each subject. We also had our midterm this week and I didn't do as good as I wanted to, I definitely need to focus some more on my studies.

Concurrency and Threads

Concurrency is the ability of a system to handle multiple tasks at the same time. Threads are the smallest units of execution within a process. Concurrency allows threads to run independently, improving efficiency, especially on multi-core processors.

Key Takeaways:

  • Concurrency enables better CPU utilization.

  • Threads share the same memory space within a process.

  • Context switching allows threads to appear to run in parallel.

  • Can lead to race conditions if not properly synchronized.


Threads API

Threads APIs provide the functions and mechanisms to create, manage, and synchronize threads. Common APIs include POSIX threads (pthreads) in C, Java Thread class, and threading libraries in other languages.

Key Takeaways:

  • pthread_create, pthread_join (C) or Thread.start(), Thread.join() (Java) are common functions.

  • APIs typically include thread lifecycle management and synchronization primitives (mutexes, condition variables).

  • Thread creation has overhead, so excessive use can degrade performance.


Locks

Locks are synchronization mechanisms that prevent multiple threads from accessing shared resources simultaneously to avoid race conditions.

Key Takeaways:

  • Mutex (Mutual Exclusion) is the most common lock type.

  • Only one thread can hold a lock at a time.

  • Improper use can lead to deadlocks, livelocks, or starvation.

  • Lock granularity matters: fine-grained locks offer better performance but increase complexity.


Lock-Based Data Structures

These are data structures (e.g., queues, stacks) that use locks to ensure thread-safe operations, meaning that multiple threads can safely interact with them without corrupting the data.

Key Takeaways:

  • Use locks internally to synchronize access to data.

  • Performance can degrade with high contention.

  • Simpler to implement than lock-free structures but may block threads.

  • Examples: ConcurrentLinkedQueue, synchronized lists/maps.



Comments

Post a Comment

Popular posts from this blog

Computer Science BS Journal: Week 4

  Part One: Set Your Educational Goals  Something I want to achieve by the end of this CS program at Monterey Bay is to have a portfolio full of projects. We learned in the recent weeks that a portfolio is more important than a resume for a programmer and I stand by that. I would like to have several large scale projects completed with my group and perhaps a few solo projects in said portfolio so I may display all that I have learned. My goal? Port-Fillio (Fill out my portfolio). Part Two: Set Your Career Goals      It may not seem like much but my career goals are sort of simple. I want to be a full-stack developer, the company I work for does not matter to me so much as the work-life balance. Traveling is very important to me so a remote job that gives me the freedom to move around is a must. I envision myself with my significant other putting in our hours and then going out to explore a new country we just landed in. This lifestyle has already been attained b...
Read more

Computer Science BS Journal (CST363) : Week 2

 Class: CST363-30_2253 ( Intro to Database Systems) SQL has the flexibility to join tables on any column(s) using any predicate (=, >, < ).    Most of the time the join will use equality between a primary and foreign key.   Think of example where joining on something other than keys would be needed.  Write the query both as an English sentence and in SQL.  If you can't think of your own example, search the textbook or internet for an example. English Sentence: Imagine you are working with a database that stores information about employees and their salary performance. You may want to find the employees who are earning more than the average salary in their department. In this case, you would join the employee table with the salary data table using the salary amount, not the keys, in order to compare each employee's salary with the department's average. Query:   SELECT e.employee_name, e.department_id, s.salary FROM employees e JOIN salaries ...
Read more

Computer Science BS Journal (CST363) : Week 5

 This marks the 5th week of CST363 and things are going great so far. This week we designed a prescription database, practiced transactions on MySQL as well as practiced some SQL in our homework 3 assignment. I had fun making the database for the prescriptions, I still get a little confused when it comes to the 1:1 or 1:M relationships so I had to go back and review a bit to be sure I was correct. Homework 3 and Lab 15 were pretty straightforward but they were good material to practice what was taught to us thus far. The web site  "Use the Index Luke"  has a page on "slow indexes".    https://use-the-index-luke.com/sql/anatomy/slow-indexes If indexes are supposed to speed up performance of query,  what does the author mean by a slow index?      After reading through the article I can conclude a few things.  What is a "slow index"? A slow index is one that exists and is technically used by the query planner, but results in poor performanc...
Read more