25일차 강의 정리


스레드 스케줄링

Thread.MIN_PRIORITY => 1

Thread.NORM_PRIORITY => 5

Thread.MAX_PRIORITY => 10

1~10 까지의 우선순위가 있어서, 높을 수록 실행 할 확률이 높아 진다고 보면된다.(먼저실행할 확률)

스케쥴링의 두번째로는 join()이 있어서, 우선순위로 지정한 메소드 먼저 끝낼수있게 한다.

소스1

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
class Pm00 extends Thread{
    Pm00 me;
    public Pm00(String name){
        super(name);
    }
    void setMe(Pm00 me){
        this.me = me;
    }
    @Override
    public void run() {
        try{
            if(me!=null)me.join();
        }catch(InterruptedException ee){
            ee.printStackTrace();
        }
        
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.getName()+" 스레드 순위 "+this.getPriority());        //디폴트로 5,항상동일
        }
    }
}
 
public class Ex00 {
    public static void main(String[] args) {
        Pm00 me1 = new Pm00("1번");
        Pm00 me2 = new Pm00("2번");
        Pm00 me3 = new Pm00("3번");
        
        me1.setPriority(Thread.MIN_PRIORITY);//1    //디폴트 순위는 무조건 5로시작
        me2.setPriority(Thread.NORM_PRIORITY);//5    //1(낮은순위) ~ 10(높은 순위)
        me3.setPriority(Thread.MAX_PRIORITY);//10    //우선순위를 높게주면 실행기회가높아진다
        
        me1.start();
        me2.setMe(me1);    //me1이끝날때까지 기다린다
        me2.start();
        me3.setMe(me2);    //me2이끝날때까지 기다린다
        me3.start();
 
        System.out.println("main end.");
    }
}
cs

결과1

소스2

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
class Am02 implements Runnable{
    
    @Override
    public void run() {
        for (int i = 0; i < 6; i++) {
            Thread thr = Thread.currentThread();
            thr.setPriority(Thread.MIN_PRIORITY+i);
            try {
                thr.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(thr.getName()+":"+thr.getPriority());
        }
    }
}
public class Ex02 {
    public static void main(String[] args) {
        Am02 am2 = new Am02();
        
        Thread thr1 = new Thread(am2,"th1");
        Thread thr2 = new Thread(am2,"th2");
        Thread thr3 = new Thread(am2,"th3");
 
        try{
            thr1.start();
            thr1.join(100);        //( )시간동안 thr1을 실행
            thr2.start();
            thr2.join();
            thr3.start();
            thr3.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("main end");
        
    }
}
cs

결과2


동기화

소스

특정블록의 동기화

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
class Bank {
    int money;
 
    public Bank() {
        money = 0;
    }
}
class ATM extends Thread{
    Bank bank;
    public ATM(Bank bank){
        this.bank = bank;
    }
    
    //특정 블록의 동기화방법
    @Override
    public void run() {
        add(1000);
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        del(500);
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        del(300);
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        del(200);
    }
    void add(int money){
        synchronized (bank){        //임계영역코딩(동기화할 객체 또는 동기화할 클래스명)
            this.bank.money+=money;
            System.out.println("cd입금: "+money+"원, 은행잔고: "+this.bank.money+"원");
        }
    }//add end
    synchronized void del(int money){
        synchronized (bank) {
            if (this.bank.money >= 0 && this.bank.money >= money) {
                this.bank.money -= money;
                System.out.println("cd출금: " + money + "원, 은행잔고: "
                        + this.bank.money + "원");
            } else {
                System.out.println("잔고부족");
            }
        }
    }//del end
}//ATM class end
 
public class Ex03 {
    public static void main(String[] args) {
        Bank bank = new Bank();
        ATM atm1 = new ATM(bank);
        ATM atm2 = new ATM(bank);
        ATM atm3 = new ATM(bank);
 
        System.out.println("잔고 : "+ bank.money+"원");
        atm1.start();
        atm2.start();
        atm3.start();
        try {
            atm1.join();
            atm2.join();
            atm3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("잔고 : "+ bank.money+"원");
    }
 
}
cs

메서드 동기화

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
class Bank {
    int money;
 
    public Bank() {
        money = 0;
    }
 
    // 메서드 동기화방법
      synchronized void add(int money) { 
        this.money += money;
        System.out.println("cd입금: " + money + "원, 은행잔고: " + this.money + "원");
 
    }// add end
 
    synchronized void del(int money) {
        if (this.money >= 0 && this.money >= money) {
            this.money -= money;
            System.out.println("cd출금: " + money + "원, 은행잔고: " + this.money + "원");
        } else {
            System.out.println("잔고부족");
        }
    }// del end
}
class ATM extends Thread{
    Bank bank;
    public ATM(Bank bank){
        this.bank = bank;
    }
    
    //메서드 동기화방법
     @Override
    public void run() {
        bank.add(1000);
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        bank.del(500);
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        bank.del(300);
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        bank.del(200);
    }
}//ATM class end
 
public class Ex03 {
    public static void main(String[] args) {
        Bank bank = new Bank();
        ATM atm1 = new ATM(bank);
        ATM atm2 = new ATM(bank);
        ATM atm3 = new ATM(bank);
 
        System.out.println("잔고 : "+ bank.money+"원");
        atm1.start();
        atm2.start();
        atm3.start();
        try {
            atm1.join();
            atm2.join();
            atm3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("잔고 : "+ bank.money+"원");
    }
}
cs

결과

3개의 스레드가 동시에돌아도 문제없다.

소스

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class ATM2 implements Runnable{
    int money;
    
    public ATM2() {this.money=0;}
    
    @Override
    public void run() {
        add(1000);
        try {
            Thread.currentThread().sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        del(500);
        try {
            Thread.currentThread().sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        del(300);
        try {
            Thread.currentThread().sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        del(200);
    }
 
    void add(int money){
        synchronized (this) {
            this.money+=money;
            System.out.println(Thread.currentThread().getName());
            System.out.println("cd입금-"+money+"원, 은행잔고:"+this.money+"원");
        }
    }
    void del(int money){
        synchronized (this) {
            if(this.money>=0 && this.money>=money){
                this.money -=money;
                System.out.println(Thread.currentThread().getName());
                System.out.println("cd출금-"+money+"원, 은행잔고:"+this.money+"원");
            }else{
                System.out.println("잔고 부족");
            }
        }
    }
}
 
public class Ex05 {
    public static void main(String[] args) {
        ATM2 bank = new ATM2();
        System.out.println("잔고:"+bank.money+"원");
        Thread atm1 = new Thread(bank,"ATM1");
        Thread atm2 = new Thread(bank,"ATM2");
        Thread atm3 = new Thread(bank,"ATM3");
        atm1.start();
        atm2.start();
        atm3.start();
        try {
            atm1.join();
            atm2.join();
            atm3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("잔고:"+bank.money+"원");
    }
 
}
cs

결과

*state...>?


저작자표시 비영리 변경금지

'* Programming > JAVA' 카테고리의 다른 글

SMS 참고 사이트  (0) 2018.03.08
DAY25 IO  (0) 2016.08.11
DAY24 스레드  (0) 2016.08.08
DAY24 제네릭2(메소드제네릭,와일드카드)  (0) 2016.08.08
DAY23 제네릭1  (0) 2016.08.08

24일차 강의 정리


스레드


소스1

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
class Pm01 extends Thread{        //Thread 상속
    @Override
    public void run(){
        for (int i = 0; i < 6; i++) {
            try {
                Thread.sleep(1000);    //1000분의 1초 휴식->1초
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("스레드로 실행");
        }
    }
}
 
public class Ex01 {
 
    public static void main(String[] args) {
        // 스레드
        System.out.println("main start");
        Pm01 pm01 = new Pm01();
        pm01.start();        //새로운 스레드로  run()실행
        pm01 = new Pm01();    //새로운 객체
        pm01.start();        //새로운 스레드로  run()실행
        
        for (int i = 0; i < 6; i++) {
            try {
                Thread.sleep(1000);     //휴식->1초
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main i : "+i);
        }
        System.out.println("main end");
        
    }//main end
}//class end
cs

결과1

소스2

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
public class Ex02 extends Thread{
 
    public static void main(String[] args) {
        System.out.println("main start");
        Ex02 me = new Ex02();    //이객체를 통한 두번째 스레드
        me.start();                //run()이 실행
        for (int i = 0; i < 10; i++) {
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("main() i: "+i);
        }
        System.out.println("main end.....");
 
    }
    @Override
    public void run(){    //main 에서 실행해서 run을 스레드로 사용
        for (int i = 0; i < 10; i++) {
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("new Ex02 thread run() i: "+i);
        }
        System.out.println("run end...........");
    }
}
cs

결과2

소스3

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
53
54
class Pm44 extends Thread{
    public Pm44(String name) {
        super(name);
    }
    @Override
    public void run() {
        for(int i=0; i<5; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.getName());
        }
    }
}
 
class Pm04 implements Runnable {    //인터페이스로 상속받아서 스레드 사용하기
 
    @Override
    public void run() {
        for(int i=0; i<5; i++){
            try {
                Thread.sleep(1000);        //해당 스레드를 1/1000잠시 휴식(1s)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread thr = Thread.currentThread();
            System.out.println(thr.getName());
        }
    }
    
}
 
public class Ex04 {
 
    public static void main(String[] args) {
        Pm04 pm4 = new Pm04();
        Thread thread = new Thread(pm4,"스레드 추가");        //""가 변경된 스레드 이름
        thread.start();
        Pm44 pm44 = new Pm44("상속을 통한");
        pm44.start();
        for(int i=0; i<5; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            System.out.println(Thread.currentThread());        //[스레드명, 스케줄링, ..?뭔단?]
            System.out.println(Thread.currentThread().getName());
        }
    }
 
}
cs

결과3



저작자표시 비영리 변경금지

'* Programming > JAVA' 카테고리의 다른 글

DAY25 IO  (0) 2016.08.11
DAY25 스레드 스케줄링&동기화  (0) 2016.08.08
DAY24 제네릭2(메소드제네릭,와일드카드)  (0) 2016.08.08
DAY23 제네릭1  (0) 2016.08.08
DAY22 큐&스택  (0) 2016.08.04

24일차 강의 정리


1. 메소드 제네릭

소스1 (Number 상속받는 메소드 제네릭)

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
class Box01<T>{        //내가정한 타입이 들어온다(제네릭)
    T obj;
 
    void setObj(T obj){
        this.obj = obj;
    }
    T getObj(){
        return this.obj;
    }
}
 
//아래클래스를 숫자에 한정하여 제네릭을 제한하여 사용
//(Box01<String> box = Template.<String>getMethod("s"); 불가! String은 Number에 상속받지않기때문)
class Template{     //^아래<>가 메소드 제네릭위치(리턴타입의 앞)
    public static <T extends Number> Box01<T> getMethod(T a){        //메소드에 제네릭(Number 상속)
        Box01<T> box = new Box01<T>();
        box.setObj(a);
        return box;
    }
}
public class Ex01 {
    public static void main(String[] args) {
 
        Box01<Integer> box = Template.<Integer>getMethod(1000);        //*이것이 중요
        System.out.println(box.getObj());        
 
    }
}
cs

결과1

소스2

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
class Box01<T>{        //내가정한 타입이 들어온다(제네릭)
    T obj;
 
    void setObj(T obj){
        this.obj = obj;
    }
    T getObj(){
        return this.obj;
    }
}
 
class Template{     //^아래<>가 메소드 제네릭위치(리턴타입의 앞)
    public static <T extends CharSequence> Box01<T> getMethod(T a){            //메소드에 제네릭2
        Box01<T> box = new Box01<T>();
        box.setObj(a);
        return box;
    }
}
public class Ex01 {
    public static void main(String[] args) {
        
        Box01<StringBuffer> box = Template.<StringBuffer>getMethod(new StringBuffer("1000"));        //*이것이 중요
        System.out.println(box.getObj());
        
    }
}
cs

결과2

2. 와일드카드

형식 : <? extends Number>

Number자리가 class가아닌 Interface 이더라도 extends를 사용한다.

소스

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
class Box02<T>{        //내가정한 타입이 들어온다(제네릭)
    T obj;
 
    void setObj(T obj){
        this.obj = obj;
    }
    T getObj(){
        return this.obj;
    }
}
 
public class Ex02 {
    public static void main(String[] args) {
        
        Box01<?> box = new Box01<Integer>();        //?는 와일드카드
        box = new Box01<String>();
        box = new Box01<Double>();
        
        Box01<? extends Number> box1 = new Box01<Integer>();        //?는 와일드카드
        box1 = new Box01<Double>();
//        box3 = new Box01<String>();    //오류
        
        Box01<? super Integer> box2 = new Box01<Integer>();        //?는 와일드카드
        box2 = new Box01<Number>();            //상위클래스만 가능
        box2 = new Box01<Object>();
 
    }
}
cs

결과가 없는 소스로 

어떠한 형식으로 사용이 되는지 확인만 하는 소스이다.


저작자표시 비영리 변경금지

'* Programming > JAVA' 카테고리의 다른 글

DAY25 스레드 스케줄링&동기화  (0) 2016.08.08
DAY24 스레드  (0) 2016.08.08
DAY23 제네릭1  (0) 2016.08.08
DAY22 큐&스택  (0) 2016.08.04
DAY22 컬렉션프레임워크 Map  (0) 2016.08.03

23일차 강의 정리


컬렉션프레임워크

소스1 (* ArrayList, HashSet, TreeSet)

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
public class Ex01 {
    public static void main(String[] args) {        
        ArrayList<Integer> list = new ArrayList<Integer>();    //제네릭<>
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(3));
//        list.add("사");    //Integer 외에 오류
        
//        for (int i = 0; i < list.size(); i++) {
//            Integer temp = list.get(i);
//            System.out.println(temp);
//        }
        for(Integer i:list){    //foreach문, 개선된 for문
            System.out.println(i);
        }
        System.out.println("------------------------------");
        int[][] arr={{1,2},{3,4},{5,6},{7,8,9}};
        for(int[] i :arr){
            for(int j : i){
            System.out.print(j+" ");
            }
            System.out.println();
        }
        
        System.out.println("------------------------------");
//        HashSet<String> set = new HashSet<String>();        //정렬이없는 Set
        TreeSet<String> set = new TreeSet<String>();        //정렬 Set
        //tree는 제네릭이없을경우 다른타입이 존재할시 오류(순서를 정할수없어서)
        set.add("하나");
        set.add("둘");
//        set.add(3);        //오류
        set.add("넷");
        
//        Iterator ite = set.iterator();
//        while(ite.hasNext()){
//            System.out.println(ite.next());
//        }
        for(String temp : set){        //foreach문
            System.out.println(temp);
        }
        
    }//main end
}//class end
cs

결과1

소스2

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
class Box02<T>{
    T obj;
 
    void add(T obj){
        this.obj = obj;
    }
 
    T get(){
        return obj;
    }
}
class Paper{
    @Override
    public String toString() {
        return "종이입니다.";
    }
}
class Pen{
    @Override
    public String toString(){
        return "나는 펜입니다.";
    }
}
 
public class Ex02 {
    public static void main(String[] args) {
        Box02<Pen> box = new Box02<Pen>();        
        Pen pen = new Pen();
        box.add(pen);
        System.out.println(box.get());
 
        Box02<Paper> box2 = new Box02<Paper>();
        Paper per = new Paper();
        box2.add(per);
        System.out.println(box2.get());        
    }//main end
}//class end
cs

결과2

소스3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Ex03 {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<String,String>();
        map.put("하나", "a");
        map.put("둘", "abcd");
        map.put("셋", "123456");
        map.put("넷", "1234");
//        Set<String> key = map.keySet();
        TreeSet<String> key = new TreeSet(map.keySet());
        Iterator<String> ite = key.iterator();
        String obj = ite.next();
//        while(ite.hasNext()){                    //무한루프
//            System.out.println(map.get(obj));    //값
//            System.out.println(obj);            //key값
//        }
        Set<String> set = map.keySet();
        for(String key2 : set){
            System.out.println(key2+":"+map.get(key2));
        }
 
    }//main end
}//class end
cs

결과3

소스4

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
class Box04<T,M>{
    T pen;
    M par;
    
    void set(T pen, M par){
        this.pen=pen;
        this.par=par;
    }
    T getPen(){
        return this.pen;
    }
    M getPar(){
        return this.par;
    }
}
class Pen04{}
class Paper04{}
 
public class Ex04 {
    public static void main(String[] args) {
//        Box04<Pen04,Paper04> box = new Box04<Pen04,Paper04>();
//        box.set(new Pen04(), new Paper04());
        
        Box04<String,Integer> box = new Box04<String,Integer>();
        box.set("aaaaaaaaaa", 1234);
        System.out.println(box.getPen());
        System.out.println(box.getPar());
    }//main end
}//class end
cs

결과4



저작자표시 비영리 변경금지

'* Programming > JAVA' 카테고리의 다른 글

DAY24 스레드  (0) 2016.08.08
DAY24 제네릭2(메소드제네릭,와일드카드)  (0) 2016.08.08
DAY22 큐&스택  (0) 2016.08.04
DAY22 컬렉션프레임워크 Map  (0) 2016.08.03
DAY22 컬렉션프레임워크 Set  (0) 2016.08.03

+ Recent posts

티스토리툴바