(22.10.28)Java 프로그래밍: 직렬화 역직렬화 실습, Thread 실습

List 직렬화를 사용한 CRUD 실습

이용자가 키보드에서 사원정보를 관리하는 프로그램을 작성하려고 한다.

텍스트 파일을 사용하지 않고 List의 직렬화를 사용하여 작성한다.

사원정보 추가의 예 키보드 입력 > Employee객체 생성 >리스트에 저장 > 리스트 직렬화

목록 출력의 예 직렬화 된 리스트를 복원 > 화면에 리스트 출력

 

Employee 클래스 코드

import java.io.Serializable;
 
public class Employee implements Serializable
{
    private int empno;  
    private String ename; 
    private int deptno;
    private String hiredate;
    
    public Employee(String[] strings) {}
    public Employee() {} 
    public Employee(int empno, String ename, int deptno, String hiredate) {
        this.setEmpno(empno);
        this.setEname(ename);
        this.setDeptno(deptno);
        this.setHiredate(hiredate);
    }
    @Override
    public boolean equals(Object obj) {
        Employee other = (Employee)obj;
        return this.empno==other.empno;
    }
    public String toString() {
        
        return String.format("%d\t%s\t%d\t%s", 
                empno,ename,deptno,hiredate);
    }
    public int getEmpno() {
        return empno;
    }
    public void setEmpno(int empno) {
        this.empno = empno;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public int getDeptno() {
        return deptno;
    }
    public void setDeptno(int deptno) {
        this.deptno = deptno;
    }
    public String getHiredate() {
        return hiredate;
    }
    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
}

 

Main 클래스 코드

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Scanner;
import com.ezen.javaoop.Employee;
 
public class SerializationMain 
{
    public static void main(String[] args) 
    {
        boolean go = true;
        Menu menu = null;
        while(go)
        {
            menu = menu();
            if(menu==null) continue;
            switch(menu)
            {
            case LIST: printlist(list());    break;
            case ADD:  add(getInput());        break;
            case FIND: printEmp(find());    break;
            case UPDATE: update(); break;
            case DELETE: delete(); break;
            case EXIT: go=false; break;
            default: System.out.println("메뉴 입력 오류");
            }
        }
        
        System.out.println("프로그램 종료");
    }
    static enum Menu { LIST, ADD, FIND, UPDATE, DELETE, EXIT};
    static String f = new String("D:/java_test/list_emp.ser");
 
    
    private static Menu menu()
    {
        String mlist = "목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):";
        Scanner kbd = new Scanner(System.in);
        System.out.print(mlist);
        String m = kbd.nextLine().strip();
        Menu menu = null;
        switch(m)
        {
        case "s": menu = Menu.LIST;      break;
        case "a": menu = Menu.ADD;      break;
        case "f": menu = Menu.FIND;      break;
        case "u": menu = Menu.UPDATE;      break;
        case "d": menu = Menu.DELETE;      break;
        case "x": menu = Menu.EXIT;      break;
        default:  menu = null;
        }
        return menu;
    }
    private static  Employee getInput()
    {
        Scanner kbd = new Scanner(System.in);
        try {
            System.out.print("사원번호:");
            int empno = kbd.nextInt();
            kbd.nextLine();
            
            System.out.print("이름:");
            String ename = kbd.nextLine().strip();
            
            System.out.print("부서번호:");
            int deptno = kbd.nextInt();
            kbd.nextLine();
            
            System.out.print("입사일:");
            String hiredate = kbd.nextLine().strip();
            return new Employee(empno,ename,deptno,hiredate);
        }catch(Exception e) {
            System.err.println("키보드 입력 오류");
        }
        return null;
    }
    private static void add(Employee emp)
    {
        if(emp==null) {
            System.err.println("다시 시도 하세요.");
        }
        ArrayList<Employee> list = deSerialization();
        if(list.contains(emp)) {
            System.err.println("사번은 중복이 안됩니다.");
            return;
        }
        
        if(list.add(emp) && Serialization(list)) {
            System.out.println("추가 성공");
        }else {
            System.out.println("추가 실패");
        }
    }
    private static ArrayList<Employee> list(){
        
        ArrayList<Employee> list = deSerialization();
        if(list==null) {
            return null;
        }
        return list;
    }
    private static void printlist(ArrayList<Employee> list) {
        if(list!=null) {
            for(int i=0;i<list.size();i++) {
                System.out.println(list.get(i));
            }
        }else System.err.println("목록이 비었습니다.");
    }
    private static Employee find()
    {
        Scanner kbd = new Scanner(System.in);
        System.out.print("찾을 사원 번호는:");
        int empno = kbd.nextInt();
        kbd.nextLine();
        
        Employee kwd = new Employee();
        kwd.setEmpno(empno);
        ArrayList<Employee> list = deSerialization();
        if(list.contains(kwd))
        {
            return list.get(list.indexOf(kwd));
        }
        return null;
    }
    private static void update()
    {
        Scanner kbd = new Scanner(System.in);
        System.out.print("수정할 사원 번호:");
        int empno = kbd.nextInt();
        kbd.nextLine();
        
        Employee kwd = new Employee();
        kwd.setEmpno(empno);
        ArrayList<Employee> list = deSerialization();
        
        if(list.contains(kwd))
        {
            System.out.print("수정할 부서 번호:");
            int deptno = kbd.nextInt();
            kbd.nextLine();
            
            list.get(list.indexOf(kwd)).setDeptno(deptno);
            
            Serialization(list);
            System.out.println("사원 정보 수정 성공");
        }else {
            System.out.println("사원 정보 수정 실패");
        }
    }
    private static void delete()
    {
        Scanner kbd = new Scanner(System.in);
        System.out.print("삭제할 사원 번호:");
        int empno = kbd.nextInt();
        kbd.nextLine();
        
        Employee kwd = new Employee();
        kwd.setEmpno(empno);
        
        ArrayList<Employee> list = deSerialization();
        
        if(list.contains(kwd))
        {
            list.remove(list.indexOf(kwd));
            Serialization(list);
            System.out.println("삭제 성공");
        }else {
            System.out.println("삭제 실패");
        }
    }
    private static void printEmp(Employee emp)
    {
        System.out.println(emp);
    }
    private static boolean Serialization(ArrayList<Employee> list) {
        try {
            File ser = new File(f);
            FileOutputStream fout = new FileOutputStream(ser);
            ObjectOutputStream obj = new ObjectOutputStream(fout);
            obj.writeObject(list);
            obj.close();
            return true;
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    private static ArrayList<Employee> deSerialization() {
        try {
            File ser = new File(f);
            if(!ser.exists()) {
                return new ArrayList<Employee>();
            }
            FileInputStream fin = new FileInputStream(ser);
            ObjectInputStream oin = new ObjectInputStream(fin);
            ArrayList<Employee> list = (ArrayList<Employee>)oin.readObject();
            oin.close();
            return list;    
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

 

 

콘솔 값:

목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):s
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):a
사원번호:11
이름:해린
부서번호:23
입사일:22-10-28
추가 성공
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):s
11 해린 23 22-10-28
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):a
사원번호:12
이름:하니
부서번호:23
입사일:22-10-28
추가 성공
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):f
찾을 사원 번호는:11
11 해린 23 22-10-28
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):u
수정할 사원 번호:12
수정할 부서 번호:30
사원 정보 수정 성공
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):s
11 해린 23 22-10-28
12 하니 30 22-10-28
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):d
삭제할 사원 번호:11
삭제 성공
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):s
12 하니 30 22-10-28
목록(s), 추가(a), 검색(f), 수정(u), 삭제(d), 종료(x):x
프로그램 종료

 

사원을 추가할 땐 파일로 직렬화 된 데이터를 역직렬화 해주어 리스트 객체를 만들고 거기에 새로운 사원 정보를 추가해준 뒤 새롭게 갱신된 리스트를 직렬화 하여 파일에서도 추가된 정보가 들어 있어야한다.

마찬가지로 수정 및 삭제 기능에서도 역직렬화 하여 리스트에서 찾고자 하는 정보를 찾고 찾았으면 수정 또는 삭제 해주어 다시 직렬화 하여 파일 정보도 수정해 주어야한다.

---

●Tread●

프로세스 :cpu가 지금 실행 중인 프로그램
쓰레드 :  프로세스 안에서 독립적으로 실행될 수 있는 소규모 프로세스
동시에 로직을 수행하기 위해서는 다수개의 cpu가 필요했었다.
하지만 언어차원에서 최초로 자바가 동시실행 (병행처리)기능을 냈다.

 

멀티 프로세싱 - 다수개의 프로그램이 한 운영체제안에서 동시에 실행될 수 있는 것

 

멀티 쓰레딩 - 한 프로세스 안에서 다수개의 로직이 동시에 실행되는 것

 

타임 슬라이싱- 시분할 방식을 이용하여 다수개의 로직을 순차적으로 실행

자바 언어의 Thread - 가상의 CPU (VCPU)라 생각하면 쉽다.
가상의 CPU에게 개발자가 작성한 코드를 할당하고 실행하면 가상의 CPU가 실행된다.

자바는 기본적으로 Thread Class를 지원해준다.

쓰레드는 코드를 공유할 수 있다.
가사의 cpu이 thread가 실행 할 수 있는 코드는 runnable 인터페이스를 구현해야한다.

 

쓰레드를 만들고 실행 시켜보기

public class ThreadMain 
{
    public static void main(String[] args) 
    {
        Thread t1 = new Thread(new Code1());
        t1.setName("올리기 쓰레드");
        t1.start();
    }
    static class Code1 implements Runnable{
 
        @Override
        public void run() {
            for(int i=0;i<10;i++) {
                System.out.print(i+" ");
                try {
                    Thread.sleep(1000);//1000mili-seconds =1sec
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
            String tname = Thread.currentThread().getName();
            System.out.println(tname+" 종료(die)");
        }
    }
}
 

콘솔 값:

0 1 2 3 4 5 6 7 8 9 올리기 쓰레드 종료(die)

 

1초에 한 번씩 숫자가 나타나는 걸 볼 수 있다.

---

두개의 쓰레드를 동시에 실행 시켜보기

public class ThreadMain 
{
    public static void main(String[] args) 
    {
        Thread t1 = new Thread(new Code1());
        Thread t2 = new Thread(new Code2());
        t1.setName("올리기 쓰레드");
        t2.setName("내리기 쓰레드");
        t1.start();
        t2.start();
    }
    static class Code1 implements Runnable{
 
        @Override
        public void run() {
            for(int i=0;i<10;i++) {
                String tname = Thread.currentThread().getName();
                System.out.println(tname+" "+i+" ");
                try {
                    Thread.sleep(1000);//1000mili-seconds =1sec
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
            String tname = Thread.currentThread().getName();
            System.out.println(tname+" 종료(die)");
        }
    }
    static class Code2 implements Runnable{
 
        @Override
        public void run() {
            for(int i=9;i>=0;i--) {
                String tname = Thread.currentThread().getName();
                System.out.println(tname+" "+i+" ");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
            String tname = Thread.currentThread().getName();
            System.out.println(tname+" 종료(die)");
        }
    }
}
 

콘솔 값:

올리기 쓰레드 0 
내리기 쓰레드 9 
내리기 쓰레드 8 
올리기 쓰레드 1 
내리기 쓰레드 7 
올리기 쓰레드 2 
내리기 쓰레드 6 
올리기 쓰레드 3 
내리기 쓰레드 5 
올리기 쓰레드 4 
내리기 쓰레드 4 
올리기 쓰레드 5 
올리기 쓰레드 6 
내리기 쓰레드 3 
내리기 쓰레드 2 
올리기 쓰레드 7 
내리기 쓰레드 1 
올리기 쓰레드 8 
내리기 쓰레드 0 
올리기 쓰레드 9 
올리기 쓰레드 종료(die)
내리기 쓰레드 종료(die)

---

쓰레드 끼리 코드를 공유하게 되면 각각의 스택을 만들어 각자의 지역변수를 저장해 공유되지 않지만 멤버변수는 공유하게 된다.

public class ThreadMain 
{
    public static void main(String[] args) 
    {
        Code1 code1 = new Code1();
        Thread t1 = new Thread(code1);
        t1.setName("올리기 쓰레드");
        t1.start();
        
        Thread t2 = new Thread(code1);
        t2.setName("내리기 쓰레드");
        t2.start();
        
    }
    static class Code1 implements Runnable{
        int num;
        @Override
        public void run() {
            for(num=0;num<10;num++) {
                String tname = Thread.currentThread().getName();
                System.out.println(tname+" "+num+" ");
                try {
                    Thread.sleep(1000);//1000mili-seconds =1sec
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
            String tname = Thread.currentThread().getName();
            System.out.println(tname+" 종료(die)");
        }
    }
    static class Code2 implements Runnable{
 
        @Override
        public void run() {
            for(int i=9;i>=0;i--) {
                String tname = Thread.currentThread().getName();
                System.out.println(tname+" "+i+" ");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
            String tname = Thread.currentThread().getName();
            System.out.println(tname+" 종료(die)");
        }
    }
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

public class ThreadMain  {     public static void main(String[] args)      {         Code1 code1 = new Code1();         Thread t1 = new Thread(code1);         t1.setName("올리기 쓰레드");         t1.start();                  Thread t2 = new Thread(code1);         t2.setName("내리기 쓰레드");         t2.start();              }     static class Code1 implements Runnable{         int num;         @Override         public void run() {             for(num=0;num<10;num++) {                 synchronized(this) {                     //this는 현재 객체의 lock 플래그                     String tname = Thread.currentThread().getName();                     System.out.println(tname+" "+num+" ");                     try {                         Thread.sleep(1000);//1000mili-seconds =1sec                     } catch (InterruptedException e) {                         e.printStackTrace();                     }                 }             }             String tname = Thread.currentThread().getName();             System.out.println(tname+" 종료(die)");         }     }     static class Code2 implements Runnable{           @Override         public void run() {             for(int i=9;i>=0;i--) {                 String tname = Thread.currentThread().getName();                 System.out.println(tname+" "+i+" ");                 try {                     Thread.sleep(1000);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }              }             String tname = Thread.currentThread().getName();             System.out.println(tname+" 종료(die)");         }     } } Colored by Color Scripter

cs

콘솔 값:

올리기 쓰레드 0 
올리기 쓰레드 1 
올리기 쓰레드 2 
올리기 쓰레드 3 
올리기 쓰레드 4 
내리기 쓰레드 5 
내리기 쓰레드 6 
내리기 쓰레드 7 
내리기 쓰레드 8 
내리기 쓰레드 9 
올리기 쓰레드 10 
내리기 쓰레드 종료(die)
올리기 쓰레드 종료(die)

 

쓰레드는 랜덤으로 돌아 갔지만(쓰레드 스케줄러가 랜덤으로 정함) 값은 일정하게 올라간걸 볼 수 있다.

 

t1 t2를 스타트 시키면 Runnable pool로 가게된다. 쓰레드 스케줄러가 Runnable pool의 둘중에 무작위로 찍어서 Run으로 보낸다. 하나의 쓰레드가 run으로 가면 다른 쓰레드들은 Lock pool에서 기다리게된다. 작동한 쓰레드는  1초 쉬게 될때 Wait pool에 가서 기다리게 되고 1초가 끝난뒤 다시 Runnable pool로 간다. 뽑히지 못한 Lock pool에 있던 쓰레드들도 다시 Runnable pool로 간다. Runnable pool에서 또 스케줄러의 뽑힘을 받는다. 선택된 쓰레드는 Run에 나머지 Thread는 또다시 Lock pool로 간다.

---

Producer, Consumer 두 쓰레드를 만들어 Producer은 num값을 올리기만 하고 Consumer은 내리기만 한다.

num 변수의 값을 공유하는 상황을 만들고 num 변수 값이 항상 10~15 사이에 유지되도록 해야한다.

public class ThreadMain 
{
    public static void main(String[] args) 
    {
        Thread ori = new MyThread();
        Thread t1 = new Thread(ori);
        t1.setName("Producer");
        t1.start();
        
        
        Thread t2 = new Thread(ori);
        t2.setName("Consumer");
        t2.start();
        
    }
    static class MyThread extends Thread {
        int num;
        @Override
        public void run() 
        {    
            while(true) 
            {
                synchronized(this) 
                {
                    String tname = Thread.currentThread().getName();
                    if(tname.equals("Producer")) 
                    {    
                        ++num;
                        if(num==15) System.err.println("p->"+ num);
                        else System.out.println("p->"+ num);
                        
                        if(num==15) { 
                            notifyAll();//wait 풀에서 대기중인 c에게 통지한다.
                            try {
                                wait();// p는 wait 풀에서 대기하러 간다.
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    else if(tname.equals("Consumer")) 
                    {
                        if(num<=10) {
                            notifyAll();
                            try {
                                wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        --num;
                        if(num==10) System.err.println("c->"+ num);
                        else System.out.println("c->"+ num);
                    }
                    try {
                        wait(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

---

수를 무한히 올리면서 출력하는 기능과 초시계를 무한히 출력하는 기능을 만들어 보아라.

import java.util.Date;
 
public class ThreadMain 
{
    public static void main(String[] args) 
    {
        Code1 code1 = new Code1();
        Thread t1 = new Thread(code1);
        t1.start();
        
        Code2 code2 = new Code2();
        Thread t2 = new Thread(code2);
        t2.start();
    }
    static class Code1 implements Runnable{
        @Override
        public void run() {
            int i = 0;
            while(true) {
                System.out.println(i);
                i++;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
        }
    }
    static class Code2 implements Runnable{
        @Override
        public void run() {
            while(true) {
                System.out.println(new Date());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
        }    
    }
}

콘솔 값:

0
Fri Oct 28 17:40:53 KST 2022
1
Fri Oct 28 17:40:54 KST 2022
2
Fri Oct 28 17:40:55 KST 2022
3
Fri Oct 28 17:40:56 KST 2022
4
Fri Oct 28 17:40:57 KST 2022
5
Fri Oct 28 17:40:58 KST 2022
6
Fri Oct 28 17:40:59 KST 2022
7
Fri Oct 28 17:41:00 KST 2022
8
Fri Oct 28 17:41:01 KST 2022
9
Fri Oct 28 17:41:02 KST 2022
10
Fri Oct 28 17:41:03 KST 2022
11
Fri Oct 28 17:41:04 KST 2022
12
Fri Oct 28 17:41:05 KST 2022