multithreading and multiprocessing

Pranavi nerella — Sun, 24 Oct 2021 09:36:13 +0000

Python Multithreading:-

Multithreading is a threading technique in Python programming to run multiple threads concurrently by rapidly switching between threads with a CPU help (called context switching). Besides, it allows sharing of its data space with the main threads inside a process that share information and communication with other threads easier than individual processes. Multithreading aims to perform multiple tasks simultaneously, which increases performance, speed and improves the rendering of the application

When to use Multithreading in Python?

It is a very useful technique for time-saving and improving the performance of an application. Multithreading allows the programmer to divide application tasks into sub-tasks and simultaneously run them in a program. It allows threads to communicate and share resources such as files, data, and memory to the same processor. Furthermore, it increases the user's responsiveness to continue running a program even if a part of the application is the length or blocked.

python multiprocessing:-

Multiprocessing refers to the ability of a system to support more than one processor at the same time. Applications in a multiprocessing system are broken to smaller routines that run independently. The operating system allocates these threads to the processors improving performance of the system.

When to use Multiprocessing in Python?

Multiprocessing is essential to perform the multiple tasks within the Computer system. Suppose a computer without multiprocessing or single processor. We assign various processes to that system at the same time.
It will then have to interrupt the previous task and move to another to keep all processes going. It is as simple as a chef is working alone in the kitchen. He has to do several tasks to cook food such as cutting, cleaning, cooking, kneading dough, baking, etc.
Therefore, multiprocessing is essential to perform several task at the same time without interruption. It also makes easy to track all the tasks. That is why the concept of multiprocessing is to arise.
Multiprocessing can be represented as a computer with more than one central processor.
A Multi-core processor refers to single computing component with two or more independent units.

FILE HANDALING

Pranavi nerella — Thu, 06 May 2021 14:26:55 +0000

A file is the name of memory location where we can store data permanently under computer’s hard disk. Java language supports a set of classes in java.io package to create and maintain files. The following are some of the classes we can use to create and maintain files :

FileInputStream
FileOutputStream
FileWriter etc.,

FileOutputStream class :

This class represent data as a stream of bytes. The objects of this class can be used to open and access a file in write mode. The object for this class can be created as below :

FileOutputStream fis = new FileOutputStream(“file-name”,boolean-value); Here, if the boolean value is true, the file can be opened in append mode. If it is false,the data is overwritten from the beginning of the file every time when we execute the program.The following program demonstrates the use of this class.

/* Program to store data into a file using FileOutputStream class */

import java.io.*;

class FileWrite{

public static void main(String args[]) throws Exception {

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

System.out.println(“Enter some text “);

String data = br.readLine();

FileOutputStream fos = new FileOutputStream(“file1.txt”,true);

/* Because data is in the form of String object, convert it into byte array */

byte b[] = data.getBytes();

fos.write(b); /* writes byte array into file.txt */

fos.close();

}

FileInputStream class :

This clas represents data as a stream of bytes. The objects of this class can be used to open and access a file in read mode. The object for this class can be created as below :

FileInputStream fis = new FileInputStream(“file-name”);

The following program demonstrates the use of this class.

/* Program to read data from a file using FileInputStream class */

import java.io.*;

class FileRead {

public static void main(String args[]) throws Exception {

FileInputStream fis = new FileInputStream(“file1.txt”);

int size = fis.available(); /* available() returns no. of bytes in file1.txt */

byte b [] = new byte[size];

/* create a byte array of file size */

fis.read(b);

String data = new String(b);

/* convert the byte array to string */

System.out.println(“The contents of file1.txt are : “ + data);

}// end of main

}// end of class

FileWriter class :

This class represent data as a stream of characters. The objects of this class can be used to open and access a file in write mode. The object for this class can be created as below :

FileWriter fw = new FileWriter(filename,boolean-value);

The following program demonstrates the use of FileWriter class.

import java.io.*;

class FileWrite {

public static void main(String args[]) throws Exception {

FileWriter fw = new FileWriter(“file2.txt”,true);

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

System.out.println(“Enter some text “);

String data = br.readLine();

// convert data into equalent character array

char ch[] = data.toCharArray();

fw.write(ch);

fw.close();

} // end main

} // end class

DEV Community: Pranavi nerella

multithreading and multiprocessing

FILE HANDALING