Two threads, how to implement communication between them. (Pseudocode) - multithreading

Question

I have two threads:
Main thread :
Main thread is listening for HTTP requests,
Main thread registers handler to HTTP request used for long polling
Second thread:
Getting data from different socket.
if it finds something in data from socket, updates thread local storage,
and IF Main thread has HTTP request pending it sends data to it somehow.
How do I make Main thread and second thread communicate to each other?
Main Thread http handler pseudocode:
function mg_handler(request){
var handle = parseHandle(request.data);
var storage_name = parseStorageName(request.data);
var response = WaitForResponse(handle,storage_name);
mg_printf(rasponse);
return;
}
Second thread pseudocode:
var storage
function t_run()
{
var buf
while(1){
recvfrom(socket,buf);
var result;
bool found_something = search(buf,result);
if(found_something){
update(storage,result);
//if WaitForResponse is waiting let it continue by sending storage to it somehow.
//???
}
}
cleanup:
return;
}

Answer 1

In your scenario there is no communication between any threads. Communication would mean for example one thread controls the execution of another thread. In your case you are simply sharing data (or the memory that holds the data to be more precise).
Note, that you have to provide a synchronization mechanism in order to synchronize the concurrent access to the shared memory. Otherwise you will experience all the concurrency issues that usually come with multithreading, especially when shared memory is involved.
Most languages that support multithreading also support synchronization on compiler level.
// Shared resources.
// Requires some synchronization mechanism for thread-safe access...
shared_pending_http_request_flag;
shared_data_variable;
function main()
{
// Main thread context
startBackgroundThread();
listenToHttpRequests();
}
function startBackgroundThread()
{
// Background thread context
result_data := readDataFromSocket();
IF
main thread has set shared variable shared_pending_http_request_flag
THEN
shared_data_variable := result_data ;
}
function listenToHttpRequests()
{
// Main thread context
WHILE
listening to HTTP requests
DO
IF
there is a pending request
THEN
set the shared_pending_http_request_flag;
IF
shared_pending_http_request_flag AND shared_data_variable are both set
THEN
handle value of shared_data_variable;
}
For an object oriented language or any language that supports callbacks or method references, you should implement the Observer pattern. This removes the need to poll for changes, as the observable can simply notify the observer about changes. Generally the observable invokes a callback that was registered by the observer.