The actor model of concurrency is associated with which of the following?

You may select more than one answer but incorrect answers will reduce the total point value (the final score will never be less than zero)

In Java, the join method will...

Which of the following statements are true?

Note that you may select more than one answer but incorrect answers will reduce the overall score for the question (the final score will never be less than 0).

Which of the following statements are true?

You may select more than one answer but incorrect answers reduce the overall score (the final value can never be less than zero)

Let's say that we are using semaphores to coordinate tasks within a producer consumer environment.

Given this context, which of the following statements is true?

Note that you can select more than one answer but incorrect answers will reduce the overall score for the question (your score can never be negative)

Simple operations like move, add, store, etc, are made up of a series of smaller operations or steps (e.g., setting addresses or moving values to CPU registers). It is possible to improve performance by overlapping the execution of some of these operations.

We refer to this as...

We have the Ada code listed below. Assume that two Bar messages and two Baz messages have arrived before we get to the loop. In this case, how many messages will the Foo task process, if the task runs indefinitely and no new messages arrive.

task body Foo is
  begin
    loop
      select 
        accept Baz(parameters) do
          -- do Baz processing here
        end Baz;
      or
        accept Bar(parameters) do
          -- do Bar processing here
        end Bar;
      end select;
    end loop;
  end Foo;

Early computing systems typically allowed multiple processing "jobs" to be submitted to a central or mainframe computer that had more than one CPU. The resulting performance improvement was associated with

Lets say that we define a Java class that will store two lists, foo and bar. Both of these lists will be updated by other concurrently executing threads. So we create two synchronized methods, one to provide write access to foo, and the other to provide write access to bar. 

How many intrinsic (i.e., automatic or transparent) locks does the object provide in this case?

We have the following small piece of Ada code. If we assume that two Bar messages and two Baz messages have arrived before we reach the top of the loop, how many messages will be processed in a single iteration of the loop?

 task body Foo is
   begin
     loop
       accept Baz(parameters) do
         -- do Baz processing here
       end Baz;
       
       accept Bar(parameters) do
         -- do Bar processing here
       end Bar;
     end loop;
  end Foo;