This document provides information about multithreading and I/O in Java. It discusses the Java thread model and how to create threads using the Thread class and Runnable interface. It covers thread states, priorities, synchronization, and inter-thread communication. It also discusses I/O basics in Java including reading from the console using Console, BufferedReader and Scanner, and writing to the console and files.
Multithreading in Java allows executing multiple threads simultaneously. A thread is the smallest unit of processing and threads are lightweight sub-processes that are independent. If an exception occurs in one thread, it does not affect other threads. There are five states in the lifecycle of a thread: new, runnable, running, non-runnable (blocked), and terminated. Threads can be created by extending the Thread class or implementing the Runnable interface.
This document discusses multithreading in Java. It explains that multithreading allows executing multiple threads simultaneously by sharing a common memory area. This saves memory compared to multiprocessing. Advantages of multithreading include not blocking the user and performing multiple operations simultaneously to save time. The document also covers thread states, creating and ending threads, synchronization, scheduling, and other core multithreading concepts in Java.
The document discusses multithreading in Java. It defines a thread as the smallest unit of processing and describes how Java allows executing multiple threads simultaneously. It outlines the five states in a thread's lifecycle and how threads transition between these states. It also discusses how to create threads by extending the Thread class or implementing the Runnable interface. Additionally, it covers common thread methods like sleep(), join(), getName(), currentThread(), and setting priority. The document concludes with a brief overview of synchronization in Java.
Multi-Threading in Java power point presenetationAshokRachapalli1
Multithreading in Java allows multiple threads to execute concurrently, making it more efficient than multiprocessing due to shared memory usage and lower context-switching time. Java threads are lightweight, independent from one another, and capable of multitasking without blocking the user. The lifecycle of a thread includes states such as new, runnable, blocked, waiting, timed waiting, and terminated, with the start() method being essential to initiate a thread's execution.
The document provides an overview of Java multithreading, explaining key concepts such as threads, their life cycle, and methods for creating and managing them. It covers thread synchronization, priorities, and possible issues like deadlocks, highlighting the advantages of multithreading in terms of resource efficiency and performance. Additionally, practical examples illustrate how to implement threads using both thread classes and the Runnable interface.
The document provides an overview of Java multithreading, covering the introduction to threads, their life cycle, and methods for creating and managing them. Key concepts include thread creation by extending the thread class or implementing the Runnable interface, various states of a thread (newborn, runnable, running, blocked, dead), and techniques such as thread priority and synchronization to manage concurrent processes. It also addresses how to stop and block threads effectively, along with the concept of deadlock.
The document explains multithreading in Java, detailing how it allows multiple threads to run concurrently, improving program efficiency and resource management compared to multiprocessing. It describes the lifecycle of threads, methods of creating them, and synchronization to prevent issues like deadlocks. Additionally, it covers thread priority, various thread states, and provides examples of thread creation and synchronized methods.
A thread is an independent path of execution within a Java program. The Thread class in Java is used to create threads and control their behavior and execution. There are two main ways to create threads - by extending the Thread class or implementing the Runnable interface. The run() method contains the code for the thread's task and threads can be started using the start() method. Threads have different states like New, Runnable, Running, Waiting etc during their lifecycle.
This document discusses threads in Java programming. It defines threads as the smallest unit of program execution that can be scheduled independently. The key points covered are:
- Threads are represented by the Thread class in Java and allow for multithreaded programming.
- A thread can be created by extending the Thread class or implementing the Runnable interface.
- The life cycle of a thread includes states like new, runnable, running, blocked, and dead.
- Synchronization techniques like wait(), notify(), and synchronized blocks are used for inter-thread communication and coordination.
This document provides an overview of threads in Java, including:
- Threads allow for multitasking by executing multiple processes simultaneously. They are lightweight processes that exist within a process and share system resources.
- Threads can be created by extending the Thread class or implementing the Runnable interface. The run() method defines the code executed by the thread.
- Threads transition between states like new, runnable, running, blocked, and dead during their lifecycle. Methods like start(), sleep(), join(), etc. impact the thread states.
- Synchronization is used to control access to shared resources when multiple threads access methods and data outside their run() methods. This prevents issues like inconsistent data.
This document provides an overview of Java threading concepts including the base threading topics of thread creation methods, life cycle, priorities, and synchronization. It also covers more advanced topics such as volatile variables, race conditions, deadlocks, starvation/livelock, inter-thread communication using wait/notify, thread pools, and remote method invocation. The document includes examples and explanations of key threading mechanisms in Java like semaphores and message passing.
Concept of Java Multithreading-Partially.pptxSahilKumar542
The document explains multithreading in Java, highlighting its advantages over multiprocessing, such as lower memory usage and faster context switching. It covers thread creation, lifecycle states, and synchronization techniques to control access to shared resources. Key concepts include the use of the Thread class and the Runnable interface for implementing multithreading, as well as methods to ensure thread safety like synchronized methods and blocks.
Multithreading in Java allows executing multiple threads simultaneously by utilizing a shared memory area. It is more efficient than multiprocessing since threads are lightweight and context switching between threads is faster. There are two main ways to create threads in Java: by extending the Thread class or implementing the Runnable interface. Synchronization is used to avoid thread interference when multiple threads access shared resources concurrently. Key synchronization methods include wait(), notify(), and notifyAll().
The document discusses multithreading in Java. It covers the basics of multithreading including main threads, thread life cycles, creating multiple threads, thread priorities, synchronization, and inter-thread communication. It describes the different states a thread can be in like ready, running, blocked, and terminated. It also discusses thread priorities, synchronization techniques using monitors and messaging, and how to implement threads using the Thread class and Runnable interface.
This document provides an overview of multithreading programming in Java. It discusses key concepts like threads, the thread life cycle, creating threads by extending Thread or implementing Runnable, setting thread priorities, and synchronization. Multithreading allows concurrent execution to maximize CPU utilization and is commonly used for games, animations, and other applications requiring parallel processing. Synchronization is needed to prevent issues when multiple threads access shared resources concurrently.
The document discusses advanced concepts in Java programming such as method overriding, multithreading, synchronization, and inter-thread communication. It explains the rules and benefits of method overriding and describes how Java allows for multi-threaded applications, detailing the thread lifecycle and methods. Additionally, it covers synchronization techniques to manage shared resources among threads and provides examples to illustrate these concepts.
The document discusses multithreading in Java, outlining the concept of threads and their relation to processes and multitasking. It explains the benefits of multithreading, such as efficiency and independence of threads, and describes the lifecycle of a thread, including its different states. Additionally, it covers methods to create threads, thread priorities, and synchronization techniques for managing shared resources among threads.
Module 4 - Part 4 - Multithreaded Programming.pptxFahmaFamzin
The document provides an overview of advanced features of Java, focusing on threads and multithreading. It explains the benefits of multithreading for efficient CPU utilization, the Java thread model, thread states, synchronization, and methods for creating threads, either by implementing the Runnable interface or extending the Thread class. Specific examples and key concepts are also discussed, such as thread priorities and the importance of the main thread.
multithreading,thread and processinjava-210302183809.pptxArunPatrick2
The document discusses multithreading in Java, explaining how it enables concurrent execution of multiple threads to maximize CPU utilization. It covers key concepts such as thread creation, lifecycle, synchronization, and the differences between process-based and thread-based multitasking. Additionally, it outlines the advantages of multithreading, various methods for thread management, and the importance of synchronization for resource sharing among threads.
Multithreading in Java allows simultaneous execution of program parts, maximizing CPU time with lightweight threads that share memory. Threads can exist in various states such as new, runnable, blocked, and terminated, while multithreading is a form of multitasking specifically involving multiple threads. Threads can be created by extending the Thread class or implementing the Runnable interface, with priorities influencing their execution order.
The document provides an introduction to Java multithreading, explaining key concepts such as thread creation, life cycle, multitasking, and thread communication. It discusses process-based vs thread-based multitasking, including factors like memory allocation and efficiency, and explains thread states as managed by the Java Virtual Machine (JVM). Additionally, it covers methods for creating, terminating, and managing thread communication, along with issues like deadlock in multithreading scenarios.
The document discusses multi-threading in Java. It defines multi-threading as allowing multiple threads within a process to execute concurrently. It explains that threads share resources of the process but have their own call stacks and program counters. The document outlines the life cycle of a thread in Java and describes how to create threads by implementing the Runnable interface or extending the Thread class. It provides examples of creating and running threads concurrently in Java.
Multithreading Introduction and Lifecyle of threadKartik Dube
The document explains the concepts of processes and threads, noting that threads are lightweight processes that share resources within a process. It details the multithreading model, where multiple threads can execute simultaneously, enhancing performance and enabling better resource management. Additionally, it discusses the lifecycle of threads, various states they can occupy, methods for creating threads, and the importance of synchronization to avoid concurrency issues.
Thread is a lightweight sub-process that exists within a process. The document discusses thread creation, life cycle, methods, priority, synchronization, and deadlocks. It provides examples of creating threads by extending Thread class and implementing Runnable interface. The main thread states are newborn, runnable, running, blocked, and dead. Methods like start(), run(), sleep(), yield(), join() are described. Thread priority and synchronization techniques for shared resources are also covered, with deadlock defined as multiple threads blocked waiting indefinitely for each other.
The document provides an overview of Java multithreading, covering the introduction to threads, their life cycle, and methods for creating and managing them. Key concepts include thread creation by extending the thread class or implementing the Runnable interface, various states of a thread (newborn, runnable, running, blocked, dead), and techniques such as thread priority and synchronization to manage concurrent processes. It also addresses how to stop and block threads effectively, along with the concept of deadlock.
The document explains multithreading in Java, detailing how it allows multiple threads to run concurrently, improving program efficiency and resource management compared to multiprocessing. It describes the lifecycle of threads, methods of creating them, and synchronization to prevent issues like deadlocks. Additionally, it covers thread priority, various thread states, and provides examples of thread creation and synchronized methods.
A thread is an independent path of execution within a Java program. The Thread class in Java is used to create threads and control their behavior and execution. There are two main ways to create threads - by extending the Thread class or implementing the Runnable interface. The run() method contains the code for the thread's task and threads can be started using the start() method. Threads have different states like New, Runnable, Running, Waiting etc during their lifecycle.
This document discusses threads in Java programming. It defines threads as the smallest unit of program execution that can be scheduled independently. The key points covered are:
- Threads are represented by the Thread class in Java and allow for multithreaded programming.
- A thread can be created by extending the Thread class or implementing the Runnable interface.
- The life cycle of a thread includes states like new, runnable, running, blocked, and dead.
- Synchronization techniques like wait(), notify(), and synchronized blocks are used for inter-thread communication and coordination.
This document provides an overview of threads in Java, including:
- Threads allow for multitasking by executing multiple processes simultaneously. They are lightweight processes that exist within a process and share system resources.
- Threads can be created by extending the Thread class or implementing the Runnable interface. The run() method defines the code executed by the thread.
- Threads transition between states like new, runnable, running, blocked, and dead during their lifecycle. Methods like start(), sleep(), join(), etc. impact the thread states.
- Synchronization is used to control access to shared resources when multiple threads access methods and data outside their run() methods. This prevents issues like inconsistent data.
This document provides an overview of Java threading concepts including the base threading topics of thread creation methods, life cycle, priorities, and synchronization. It also covers more advanced topics such as volatile variables, race conditions, deadlocks, starvation/livelock, inter-thread communication using wait/notify, thread pools, and remote method invocation. The document includes examples and explanations of key threading mechanisms in Java like semaphores and message passing.
Concept of Java Multithreading-Partially.pptxSahilKumar542
The document explains multithreading in Java, highlighting its advantages over multiprocessing, such as lower memory usage and faster context switching. It covers thread creation, lifecycle states, and synchronization techniques to control access to shared resources. Key concepts include the use of the Thread class and the Runnable interface for implementing multithreading, as well as methods to ensure thread safety like synchronized methods and blocks.
Multithreading in Java allows executing multiple threads simultaneously by utilizing a shared memory area. It is more efficient than multiprocessing since threads are lightweight and context switching between threads is faster. There are two main ways to create threads in Java: by extending the Thread class or implementing the Runnable interface. Synchronization is used to avoid thread interference when multiple threads access shared resources concurrently. Key synchronization methods include wait(), notify(), and notifyAll().
The document discusses multithreading in Java. It covers the basics of multithreading including main threads, thread life cycles, creating multiple threads, thread priorities, synchronization, and inter-thread communication. It describes the different states a thread can be in like ready, running, blocked, and terminated. It also discusses thread priorities, synchronization techniques using monitors and messaging, and how to implement threads using the Thread class and Runnable interface.
This document provides an overview of multithreading programming in Java. It discusses key concepts like threads, the thread life cycle, creating threads by extending Thread or implementing Runnable, setting thread priorities, and synchronization. Multithreading allows concurrent execution to maximize CPU utilization and is commonly used for games, animations, and other applications requiring parallel processing. Synchronization is needed to prevent issues when multiple threads access shared resources concurrently.
The document discusses advanced concepts in Java programming such as method overriding, multithreading, synchronization, and inter-thread communication. It explains the rules and benefits of method overriding and describes how Java allows for multi-threaded applications, detailing the thread lifecycle and methods. Additionally, it covers synchronization techniques to manage shared resources among threads and provides examples to illustrate these concepts.
The document discusses multithreading in Java, outlining the concept of threads and their relation to processes and multitasking. It explains the benefits of multithreading, such as efficiency and independence of threads, and describes the lifecycle of a thread, including its different states. Additionally, it covers methods to create threads, thread priorities, and synchronization techniques for managing shared resources among threads.
Module 4 - Part 4 - Multithreaded Programming.pptxFahmaFamzin
The document provides an overview of advanced features of Java, focusing on threads and multithreading. It explains the benefits of multithreading for efficient CPU utilization, the Java thread model, thread states, synchronization, and methods for creating threads, either by implementing the Runnable interface or extending the Thread class. Specific examples and key concepts are also discussed, such as thread priorities and the importance of the main thread.
multithreading,thread and processinjava-210302183809.pptxArunPatrick2
The document discusses multithreading in Java, explaining how it enables concurrent execution of multiple threads to maximize CPU utilization. It covers key concepts such as thread creation, lifecycle, synchronization, and the differences between process-based and thread-based multitasking. Additionally, it outlines the advantages of multithreading, various methods for thread management, and the importance of synchronization for resource sharing among threads.
Multithreading in Java allows simultaneous execution of program parts, maximizing CPU time with lightweight threads that share memory. Threads can exist in various states such as new, runnable, blocked, and terminated, while multithreading is a form of multitasking specifically involving multiple threads. Threads can be created by extending the Thread class or implementing the Runnable interface, with priorities influencing their execution order.
The document provides an introduction to Java multithreading, explaining key concepts such as thread creation, life cycle, multitasking, and thread communication. It discusses process-based vs thread-based multitasking, including factors like memory allocation and efficiency, and explains thread states as managed by the Java Virtual Machine (JVM). Additionally, it covers methods for creating, terminating, and managing thread communication, along with issues like deadlock in multithreading scenarios.
The document discusses multi-threading in Java. It defines multi-threading as allowing multiple threads within a process to execute concurrently. It explains that threads share resources of the process but have their own call stacks and program counters. The document outlines the life cycle of a thread in Java and describes how to create threads by implementing the Runnable interface or extending the Thread class. It provides examples of creating and running threads concurrently in Java.
Multithreading Introduction and Lifecyle of threadKartik Dube
The document explains the concepts of processes and threads, noting that threads are lightweight processes that share resources within a process. It details the multithreading model, where multiple threads can execute simultaneously, enhancing performance and enabling better resource management. Additionally, it discusses the lifecycle of threads, various states they can occupy, methods for creating threads, and the importance of synchronization to avoid concurrency issues.
Thread is a lightweight sub-process that exists within a process. The document discusses thread creation, life cycle, methods, priority, synchronization, and deadlocks. It provides examples of creating threads by extending Thread class and implementing Runnable interface. The main thread states are newborn, runnable, running, blocked, and dead. Methods like start(), run(), sleep(), yield(), join() are described. Thread priority and synchronization techniques for shared resources are also covered, with deadlock defined as multiple threads blocked waiting indefinitely for each other.
A SEW-EURODRIVE brake repair kit is needed for maintenance and repair of specific SEW-EURODRIVE brake models, like the BE series. It includes all necessary parts for preventative maintenance and repairs. This ensures proper brake functionality and extends the lifespan of the brake system
Rearchitecturing a 9-year-old legacy Laravel application.pdfTakumi Amitani
An initiative to re-architect a Laravel legacy application that had been running for 9 years using the following approaches, with the goal of improving the system’s modifiability:
・Event Storming
・Use Case Driven Object Modeling
・Domain Driven Design
・Modular Monolith
・Clean Architecture
This slide was used in PHPxTKY June 2025.
https://phpxtky.connpass.com/event/352685/
OCS Group SG - HPHT Well Design and Operation - SN.pdfMuanisa Waras
This course is delivered as a scenario-based course to
provide knowledge of High Pressure and High-Temperature (HPHT) well design, drilling and completion operations. The course is specifically designed to provide an
understanding of the challenges associated with the design
and construction of HPHT wells. The course guides the
participants to work through the various well design
aspects starting from a geological well proposal with an
estimated formation pressure and temperature profile.
Working with real well data allows the participants to learn
not only theory, technicalities and practicalities of drilling
and completing HPHT wells but it also ensures that participants gain real experience in understanding the HPHT issues.
This document provides information about the Fifth edition of the magazine "Sthapatya" published by the Association of Civil Engineers (Practicing) Aurangabad. It includes messages from current and past presidents of ACEP, memories and photos from past ACEP events, information on life time achievement awards given by ACEP, and a technical article on concrete maintenance, repairs and strengthening. The document highlights activities of ACEP and provides a technical educational article for members.
2. • Multithreading in java is a process of executing
multiple threads simultaneously.
• Thread is basically a lightweight sub-process, a
smallest unit of processing. Multiprocessing and
multithreading, both are used to achieve multitasking.
• But we use multithreading than multiprocessing
because threads share a common memory area. They
don't allocate separate memory area so saves
memory, and context-switching between the threads
takes less time than process.
• Java Multithreading is mostly used in games,
animation etc.
3. Advantages of Java Multithreading
1) It doesn't block the user because threads are
independent and you can perform multiple
operations at same time.
2) You can perform many operations together
so it saves time.
3) Threads are independent so it doesn't affect
other threads if exception occur in a single
thread
4. Multitasking
• Multitasking is a process of executing multiple tasks simultaneously. We use
multitasking to utilize the CPU. Multitasking can be achieved by two ways:
• Process-based Multitasking(Multiprocessing)
• Thread-based Multitasking(Multithreading)
1) Process-based Multitasking (Multiprocessing)
• Each process have its own address in memory i.e. each process allocates separate
memory area.
• Process is heavyweight.
• Cost of communication between the process is high.
• Switching from one process to another require some time for saving and loading
registers, memory maps, updating lists etc.
2) Thread-based Multitasking (Multithreading)
• Threads share the same address space.
• Thread is lightweight.
• Cost of communication between the thread is low.
5. What is Thread in java
• A thread is a lightweight sub process, a
smallest unit of processing. It is a separate
path of execution.
• Threads are independent, if there occurs
exception in one thread, it doesn't affect
other threads. It shares a common memory
area.
6. • As shown in the above figure, thread is executed inside the
process. There is context-switching between the threads.
• There can be multiple processes inside the OS and one
process can have multiple threads.
7. Java Thread class
• Thread class is the main class on which java's
multithreading system is based.
• Thread class provide constructors and
methods to create and perform operations on
a thread.
• Thread class extends Object class and
implements Runnable interface.
9. Life cycle of a Thread (Thread States)
• A thread can be in one of the five states.
• According to sun, there is only 4 states in thread life cycle in
java new, runnable, non-runnable and terminated.
• There is no running state.
• But for better understanding the threads, we are explaining
it in the 5 states.
• The life cycle of the thread in java is controlled by JVM. The
java thread states are as follows:
– New
– Runnable
– Running
– Non-Runnable (Blocked)
– Terminated
11. 1) New
The thread is in new state if you create an instance of Thread class but
before the invocation of start() method.
2) Runnable
The thread is in runnable state after invocation of start() method, but
the thread scheduler has not selected it to be the running thread.
3) Running
The thread is in running state if the thread scheduler has selected it.
4) Non-Runnable (Blocked)
This is the state when the thread is still alive, but is currently not
eligible to run.
5) Terminated
A thread is in terminated or dead state when its run() method exits.
12. How to create thread
• There are two ways to create a thread:
• By extending Thread class
• By implementing Runnable interface.
Thread class:
• Thread class provide constructors and methods to create and
perform operations on a thread.
• Thread class extends Object class and implements Runnable
interface.
Commonly used Constructors of Thread class:
– Thread()
– Thread(String name)
– Thread(Runnable r)
– Thread(Runnable r,String name)
13. Commonly used methods of Thread class:
• public void run(): is used to perform action for a thread.
• public void start(): starts the execution of the thread.JVM calls the run() method on the thread.
• public void sleep(long miliseconds): Causes the currently executing thread to sleep (temporarily
cease execution) for the specified number of milliseconds.
• public void join(): waits for a thread to die.
• public void join(long miliseconds): waits for a thread to die for the specified miliseconds.
• public int getPriority(): returns the priority of the thread.
• public int setPriority(int priority): changes the priority of the thread.
• public String getName(): returns the name of the thread.
• public void setName(String name): changes the name of the thread.
• public Thread currentThread(): returns the reference of currently executing thread.
• public int getId(): returns the id of the thread.
• public Thread.State getState(): returns the state of the thread.
• public boolean isAlive(): tests if the thread is alive.
• public void yield(): causes the currently executing thread object to temporarily pause and allow
other threads to execute.
• public void suspend(): is used to suspend the thread(depricated).
• public void resume(): is used to resume the suspended thread(depricated).
• public void stop(): is used to stop the thread(depricated).
• public boolean isDaemon(): tests if the thread is a daemon thread.
• public void setDaemon(boolean b): marks the thread as daemon or user thread.
• public void interrupt(): interrupts the thread.
• public boolean isInterrupted(): tests if the thread has been interrupted.
• public static boolean interrupted(): tests if the current thread has been interrupted.
14. Runnable interface:
• The Runnable interface should be implemented by any
class whose instances are intended to be executed by a
thread.
• Runnable interface have only one method named run().
public void run(): is used to perform action for a thread.
Starting a thread:
• start() method of Thread class is used to start a newly
created thread.
• It performs following tasks: A new thread starts(with new
callstack).
• The thread moves from New state to the Runnable state.
• When the thread gets a chance to execute, its target run()
method will run.
15. 1) Java Thread Example by extending Thread class
class Multi extends Thread{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi t1=new Multi();
t1.start();
}
}
Output:thread is running...
16. 2) Java Thread Example by implementing Runnable interface
class Multi3 implements Runnable{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi3 m1=new Multi3();
Thread t1 =new Thread(m1);
t1.start();
}
}
Output:thread is running...
17. • If you are not extending the Thread class,your
class object would not be treated as a thread
object.
• So you need to explicitely create Thread class
object.
• We are passing the object of your class that
implements Runnable so that your class run()
method may execute.
18. Java I/O
• Java I/O (Input and Output) is used to process the input and produce the output.
• Java uses the concept of stream to make I/O operation fast. The java.io package
contains all the classes required for input and output operations.
• We can perform file handling in java by Java I/O API.
Stream
• A stream is a sequence of data.In Java a stream is composed of bytes. It's called a
stream because it is like a stream of water that continues to flow.
• In java, 3 streams are created for us automatically. All these streams are attached
with console.
1) System.out: standard output stream
2) System.in: standard input stream
3) System.err: standard error stream
• Let's see the code to print output and error message to the console.
• System.out.println("simple message");
• System.err.println("error message");
19. • Let's see the code to get input from console.
• int i=System.in.read();//returns ASCII code of 1st character
• System.out.println((char)i);//will print the character
OutputStream vs InputStream
• The explanation of OutputStream and InputStream classes are
given below:
OutputStream
• Java application uses an output stream to write data to a
destination, it may be a file, an array, peripheral device or socket.
InputStream
• Java application uses an input stream to read data from a source, it
may be a file, an array, peripheral device or socket.
• Let's understand working of Java OutputStream and InputStream by
the figure given below.
20. • OutputStream class
• OutputStream class is an abstract class. It is the super class of
all classes representing an output stream of bytes. An output
stream accepts output bytes and sends them to some sink.
24. Java FileOutputStream Class
• Java FileOutputStream is an output stream used for writing
data to a file.
• If you have to write primitive values into a file, use
FileOutputStream class. You can write byte-oriented as well
as character-oriented data through FileOutputStream class.
But, for character-oriented data, it is preferred to use
FileWriter than FileOutputStream.
FileOutputStream class declaration
• Let's see the declaration for Java.io.FileOutputStream class:
• public class FileOutputStream extends OutputStream
25. Java FileOutputStream Example 1: write byte
import java.io.FileOutputStream;
public class FileOutputStreamExample {
public static void main(String args[]){
try{
FileOutputStream fout=new FileOutputStream("D:testout.txt");
fout.write(65);
fout.close();
System.out.println("success...");
}catch(Exception e){System.out.println(e);}
}
}
Output:
Success...
The content of a text file testout.txt is set with the data A.
testout.txt
A
26. Java FileInputStream Class
• Java FileInputStream class obtains input bytes from a
file. It is used for reading byte-oriented data (streams
of raw bytes) such as image data, audio, video etc. You
can also read character-stream data. But, for reading
streams of characters, it is recommended to use
FileReader class.
Java FileInputStream class declaration
• Let's see the declaration for java.io.FileInputStream
class:
• public class FileInputStream extends InputStream
27. import java.io.FileInputStream;
public class DataStreamExample {
public static void main(String args[]){
try{
FileInputStream fin=new FileInputStream("D:testout.txt");
int i=fin.read();
System.out.print((char)i);
fin.close();
}catch(Exception e){System.out.println(e);}
}
}
Note: Before running the code, a text file named as "testout.txt" is required to be
created. In this file, we are having following content:
Welcome to javatpoint.
After executing the above program, you will get a single character from the file which
is 87 (in byte form). To see the text, you need to convert it into character.
Output:
W
![1) Java Thread Example by extending Thread class
class Multi extends Thread{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi t1=new Multi();
t1.start();
}
}
Output:thread is running...](https://image.slidesharecdn.com/multithreadinginjava-250318162633-c854efa5/85/web-programming-Multithreading-concept-in-Java-ppt-15-320.jpg)
![2) Java Thread Example by implementing Runnable interface
class Multi3 implements Runnable{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi3 m1=new Multi3();
Thread t1 =new Thread(m1);
t1.start();
}
}
Output:thread is running...](https://image.slidesharecdn.com/multithreadinginjava-250318162633-c854efa5/85/web-programming-Multithreading-concept-in-Java-ppt-16-320.jpg)
![Java FileOutputStream Example 1: write byte
import java.io.FileOutputStream;
public class FileOutputStreamExample {
public static void main(String args[]){
try{
FileOutputStream fout=new FileOutputStream("D:testout.txt");
fout.write(65);
fout.close();
System.out.println("success...");
}catch(Exception e){System.out.println(e);}
}
}
Output:
Success...
The content of a text file testout.txt is set with the data A.
testout.txt
A](https://image.slidesharecdn.com/multithreadinginjava-250318162633-c854efa5/85/web-programming-Multithreading-concept-in-Java-ppt-25-320.jpg)
![import java.io.FileInputStream;
public class DataStreamExample {
public static void main(String args[]){
try{
FileInputStream fin=new FileInputStream("D:testout.txt");
int i=fin.read();
System.out.print((char)i);
fin.close();
}catch(Exception e){System.out.println(e);}
}
}
Note: Before running the code, a text file named as "testout.txt" is required to be
created. In this file, we are having following content:
Welcome to javatpoint.
After executing the above program, you will get a single character from the file which
is 87 (in byte form). To see the text, you need to convert it into character.
Output:
W](https://image.slidesharecdn.com/multithreadinginjava-250318162633-c854efa5/85/web-programming-Multithreading-concept-in-Java-ppt-27-320.jpg)
