Linear search using Multi-threading

Last Updated : 25 Jul, 2023

Given a large file of integers, search for a particular element in it using multi-threading.

Examples:

Input : 1, 5, 7, 10, 12, 14, 15, 18, 20, 
        22, 25, 27, 30, 64, 110, 220
Output :if key = 20
Key element found

Input :1, 5, 7, 10, 12, 14, 15, 18, 20, 
       22, 25, 27, 30, 64, 110, 220
Output :if key = 202
Key not present

Prerequisite : Multi-threading

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach : First create n threads. Then, divide array in to four parts one section for each thread and apply linear search on individual section using multithreading and check whether the key element is present or not.

Command : g++ -pthread linear_thread.cpp

C++

// CPP code to search for element in a
// very large file using Multithreading
#include <iostream>
#include <pthread.h>
using namespace std;
 
// Max size of array
#define max 16
 
// Max number of threads to create
#define thread_max 4
 
int a[max] = { 1,  5,  7,  10, 12, 14, 15,  18,
               20, 22, 25, 27, 30, 64, 110, 220 };
int key = 202;
 
// Flag to indicate if key is found in a[]
// or not.
int f = 0;
 
int current_thread = 0;
 
// Linear search function which will
// run for all the threads
void* ThreadSearch(void* args)
{
    int num = current_thread++;
 
    for (int i = num * (max / 4);
         i < ((num + 1) * (max / 4)); i++) {
        if (a[i] == key)
            f = 1;
    }
}
 
// Driver Code
int main()
{
    pthread_t thread[thread_max];
 
    for (int i = 0; i < thread_max; i++) {
        pthread_create(&thread[i], NULL, ThreadSearch,
                       (void*)NULL);
    }
 
    for (int i = 0; i < thread_max; i++) {
        pthread_join(thread[i], NULL);
    }
 
    if (f == 1)
        cout << "Key element found" << endl;
    else
        cout << "Key not present" << endl;
    return 0;
}

Java

// Java code to search for element in a
// very large file using Multithreading
import java.util.concurrent.*;
 
public class Main {
    // Max size of array
    static final int max = 16;
 
    // Max number of threads to create
    static final int thread_max = 4;
 
    static int[] a = { 1,  5,  7,  10, 12, 14, 15,  18,
                       20, 22, 25, 27, 30, 64, 110, 220 };
    static int key = 202;
 
    // Flag to indicate if key is found in a[]
    // or not.
    static int f = 0;
 
    static int current_thread = 0;
 
    // Linear search function which will
    // run for all the threads
    static void ThreadSearch(int num)
    {
        for (int i = num * (max / 4);
             i < ((num + 1) * (max / 4)); i++) {
            if (a[i] == key)
                f = 1;
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        ExecutorService executor
            = Executors.newFixedThreadPool(thread_max);
 
        for (int i = 0; i < thread_max; i++) {
            executor.execute(new Runnable() {
                public void run()
                {
                    ThreadSearch(current_thread++);
                }
            });
        }
 
        executor.shutdown();
 
        while (!executor.isTerminated()) {
            // Wait for all threads to complete
        }
 
        if (f == 1)
            System.out.println("Key element found");
        else
            System.out.println("Key not present");
    }
}
 
// This code is contributed by shivhack999

Python3

import concurrent.futures
 
# Max size of array
max_val = 16
 
# Max number of threads to create
thread_max = 4
 
a = [1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220]
key = 202
 
# Flag to indicate if key is found in a[] or not
f = 0
 
# Linear search function which will run for all the threads
 
 
def thread_search(num):
    global f
    for i in range(num * (max_val // 4), (num + 1) * (max_val // 4)):
        if a[i] == key:
            f = 1
            break
 
 
# Driver Code
if __name__ == '__main__':
    with concurrent.futures.ThreadPoolExecutor(max_workers=thread_max) as executor:
        for i in range(thread_max):
            executor.submit(thread_search, i)
 
    if f == 1:
        print("Key element found")
    else:
        print("Key not present")
 
 
# This code is contributed by shiv1o43g

C#

using System;
using System.Threading;
 
namespace ThreadSearchDemo
{
  class Program
  {
    // Max size of array
    const int max = 16;
 
    // Max number of threads to create
    const int thread_max = 4;
 
    static int[] a = { 1, 5, 7, 10, 12, 14, 15, 18,
                      20, 22, 25, 27, 30, 64, 110, 220 };
    static int key = 202;
 
    // Flag to indicate if key is found in a[] or not.
    static int f = 0;
 
    static int current_thread = 0;
 
    // Linear search function which will run for all the threads
    static void ThreadSearch()
    {
      int num = Interlocked.Increment(ref current_thread) - 1;
 
      for (int i = num * (max / 4); i < ((num + 1) * (max / 4)); i++)
      {
        if (a[i] == key)
          Interlocked.Exchange(ref f, 1);
      }
    }
 
    // Driver Code
    static void Main(string[] args)
    {
      Thread[] thread = new Thread[thread_max];
 
      for (int i = 0; i < thread_max; i++)
      {
        thread[i] = new Thread(ThreadSearch);
        thread[i].Start();
      }
 
      for (int i = 0; i < thread_max; i++)
      {
        thread[i].Join();
      }
 
      if (f == 1)
        Console.WriteLine("Key element found");
      else
        Console.WriteLine("Key not present");
 
      Console.ReadKey();
    }
  }
}

Javascript

// Max size of array
const max_val = 16;
 
// Max number of threads to create
const thread_max = 4;
 
const a = [1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220];
const key = 202;
 
// Flag to indicate if key is found in a[] or not
let f = 0;
 
// Linear search function which will run for all the threads
function thread_search(num) {
  for (let i = num * (max_val / 4); i < (num + 1) * (max_val / 4); i++) {
    if (a[i] === key) {
      f = 1;
      break;
    }
  }
}
 
// Driver Code
for (let i = 0; i < thread_max; i++) {
  thread_search(i);
}
 
if (f === 1) {
  console.log("Key element found");
} else {
  console.log("Key not present");
}