function sum(){// 매개변수가 없다.

    var i, _sum = 0;    

    for(i = 0; i < arguments.length; i++){

    // argments는 약속되어 있는 특수한 변수명(argument라는 배열이 담겨있다.) 역할은 사용자가 전달한 인자가 argments 객체에 있다. 그러면 이 객체를 통해서 사용자가 전달한 인자에 

    // 접근할 수 있는 기능을 제공한다. sum()이 전달한 인자 개수를 알 수 있다.--> 사용자가 전달한 인자 수 만큼 for문의 루프를 돌린다.

        document.write(i+' : '+arguments[i]+'<br />');

        _sum += arguments[i];

    }   

    return _sum;

}

document.write('result : ' + sum(1,2,3,4));// 함수 정의 문장에 매개변수 선언 되어 있지 않지만 인자 수 상관 없다.

실행 결과)

0 : 1

1 : 2

2 : 3

3 : 4

result : 10

function zero(){

    console.log(

        'zero.length', zero.length,// 0

        'arguments', arguments.length// 0

    );

}

function one(arg1){

    console.log(

        'one.length', one.length, // 1 --> 함수 정의한 매개변수(인수) 개수

        'arguments', arguments.length // 2 --> 함수 호출시 인자 개수

    );

}

function two(arg1, arg2){

    console.log(

        'two.length', two.length,

        'arguments', arguments.length

    );

}

zero(); // zero.length 0 arguments 0 

one('val1', 'val2');  // one.length 1 arguments 2 

two('val1');  // two.length 2 arguments 1

실행결과)

zero.length 0 arguments 0

VM123:9 one.length 1 arguments 2

VM123:15 two.length 2 arguments 1

function outter(){// 외부 함수

    function inner(){ //내부 함수

        var title = 'coding everybody'; 

        alert(title);

    }

    inner();

}

outter();

실행결과)

coding everybody

function outter(){

    var title = 'coding everybody';

    function inner(){        

        alert(title);

    }

    inner();

}

outter();

실행결과)

coding everybody

function outter(){

    var title = 'coding everybody';  

    return function(){ // return했다면 그 함수는 생을 마감했다는 것이다.       

        alert(title);// title은 외부함수에 존재하는 값이다.

    }

}

inner = outter();//outter라는 함수가 생을 마감했음에도 불구하고

inner();

실행결과)

coding everybody

function factory_movie(title){ // 매개변수는 함수 안에서 지역변수로 사용되기 때문에 지역변수이다.

    return {

        get_title : function (){// 여기 메소드들은 factory_movie의 내부함수라고 보면된다.

// 변수 가져오기는 get_title을 통해서만

            return title;// factory_movie의 인자인 title이다.

        },

        set_title : function(_title){

// 변수 수정하는 것은 set_title을 통해서만 --> 보다 변수를 안전하게 사용할 수 있다.

            title = _title

        }

    }

}

ghost = factory_movie('Ghost in the shell'); 

matrix = factory_movie('Matrix');

alert(ghost.get_title()); 

alert(matrix.get_title());

// 각각 get_title()이라는 메소드가 접근하는 외부함수의 지역변수에 담겨있는 값이 서로 다르다.

ghost.set_title('공각기동대');

alert(ghost.get_title());

alert(matrix.get_title());

실행결과)

Ghost in the shell -> Matrix -> 공각기동대 -> Matrix 

1) 클로저는 객체의 메소드에서도 사용할 수 있다. 위의 예제는 함수의 리턴값으로 객체를 반환하고 있다. 

이 객체는 메소드 get_title과 set_title을 가지고 있다. 이 메소드들은 외부함수인 factory_movie의 인자값으로 전달된 지역변수 title을 사용하고 있다.

2) 동일한 외부함수 안에서 만들어진 내부함수나 메소드는 외부함수의 지역변수를 공유한다. 17행에서 실행된 set_title은 외부함수 factory_movie의 지역변수 title의 값을 '공각기동대'로 변경했다. 19행에서 ghost.get_title();의 값이 '공각기동대'인 것은 set_movie와 get_movie 함수가 title의 값을 공유하고 있다는 의미다.

3) 그런데 똑같은 외부함수 factory_movie를 공유하고 있는 ghost와 matrix의 get_title의 결과는 서로 각각 다르다. 그것은 외부함수가 실행될 때마다 새로운 지역변수를 포함하는 클로저가 생성되기 때문에 ghost와 matrix는 서로 완전히 독립된 객체가 된다.

4) factory_movie의 지역변수 title은 2행에서 정의된 객체의 메소드에서만 접근 할 수 있는 값이다. 이 말은 title의 값을 읽고 수정 할 수 있는 것은 factory_movie 메소드를 통해서 만들어진 객체 뿐이라는 의미다. JavaScript는 기본적으로 Private한 속성을 지원하지 않는데, 클로저의 이러한 특성을 이용해서 Private한 속성을 사용할 수 있게된다.

var arr = [];

for(var i = 0; i < 5; i++){

    arr[i] = function(id){

        return function(){

            return id;

        }

    }

}

for(var index in arr) {

    console.log(arr[index]());

}

실행결과)

1

2

3

4

5

5

5

5

5

5

var arr = [];

for(var i = 0; i < 5; i++){

    arr[i] = function(id) {

        return function(){

            return id;

        }

    }(i);

}

for(var index in arr) {

    console.log(arr[index]());

}

실행결과)

0

1

2

3

4

var vscope = 'global';// 전역 변수

function fscope(){

    alert(vscope);

}

fscope();

실행결과)

global

var vscope = 'global';

function fscope(){

    var vscope = 'local';// 로컬 변수

    alert('함수안 '+vscope);//local

}

fscope();

alert('함수밖 '+vscope);//grobal

실행결과)

함수 안: local 

함수 밖: global

var vscope = 'global';

function fscope(){

    vscope = 'local'; // 전역 변수

    alert('함수안='+vscope); //local

}

fscope();

alert('함수밖='+vscope); //grobal

실행결과)

함수안=local

함수밖=local

// local(전역변수인 vscope를 변경한 것이므로)

var vscope = 'global';

function fscope(){

    var vscope = 'local';

    vscope = 'local';// 지역변수가 변경

    alert('함수안='+vscope);

}

fscope();

alert('함수밖='+vscope);

실행결과)

함수안=local

함수밖=global

function a (){

    var i = 0;// i는 지역변수

}

for(var i = 0; i < 5; i++){

    a();

    document.write(i);

}

실행결과)

01234

function a (){

    i = 0;// i는 전역변수

}

for(i = 0; i < 5; i++){

    a();

    document.write(i);

}

var MYAPP = {} // MAYAPP이라는 전역변수에다 다 집어 넣음

MYAPP.calculator = { // 객체안의 속성의 값으로 다시 객체를 선언

    'left' : null,

    'right' : null

}

MYAPP.coordinate = {

    'left' : null,

    'right' : null

}

MYAPP.calculator.left = 10;

MYAPP.calculator.right = 20;

function sum(){

    return MYAPP.calculator.left + MYAPP.calculator.right;

}

document.write(sum());

실행결과)

30 

(function(){

    var MYAPP = {}

    MYAPP.calculator = {

        'left' : null,

        'right' : null

    }

    MYAPP.coordinate = {

        'left' : null,

        'right' : null

    }

    MYAPP.calculator.left = 10;

    MYAPP.calculator.right = 20;

    function sum(){

        return MYAPP.calculator.left + MYAPP.calculator.right;

    }

    document.write(sum());

}())

실행결과)

30 

function myappfn(){

    var MYAPP = {}

    MYAPP.calculator = {

        'left' : null,

        'right' : null

    }

    MYAPP.coordinate = {

        'left' : null,

        'right' : null

    }

    MYAPP.calculator.left = 10;

    MYAPP.calculator.right = 20;

    function sum(){

        return MYAPP.calculator.left + MYAPP.calculator.right;

    }

    document.write(sum());

}

myappfn(); //MYAPP은 전역변수이다.

실행결과)

30 

for(var i = 0; i < 1; i++){

    var name = 'coding everybody';

}

alert(name);//유효 범위 밖에서도 가능

실행결과)

coding everybody

var i = 5;

function a(){

    var i = 10;

    b();

}

function b(){

    document.write(i);//지역변수가 없으면 전역변수를 찾게된다.

}

a();

실행 결과)

5

1 다형성: 하나의 객체를 여러 개의 타입으로, 하나의 타입으로 여러 종류의 객체를 여러 가지 모습으로 해석될 수 있는 성격이라고 생각하면 된다.

vo.) 다형성(Ploymorphism): 'poly'는 다양한, 많은/‘morp'는 형태

2 다형성은 하나의 객체를 여러 가지 타입으로 선언할 수 있다는 뜻이다.

다형성은 개발자들에세는 간단히 말해서 하나의 사물(객체)을 다양한 타입으로 선언하고 사용할 수 있다는 의미로 해석해주면 된다. 일반적으로 어떤 객체가 하나의 분류에만 포함되는 것은 아니다. 대한민국의 국민인 동시에, 남자인 동시에, 서울에 사는 사람 등과 같이 이처럼 다형성은 어떤 사물을 여러 가지 시선으로 바라보는 모습을 생각하면 쉽게 이해할 수 있다.

3 Java에서 다형성은 상속과 인터페이스를 통해 이루어진다.

다형성의 의미는 하나의 객체를 다양한 시선(타입)으로 바라볼 수 있게 한다는 의미이다.

중요한 것은 다양한 타입으로 본다는 사실 자체가 아니라 다양한 타입으로 객체를 바라보게 되면 호출할 수 있는 메소드 역시 타입에 따라 달라진다는 것이다. 상속의 오버라이딩을 설명하면서 오버라이딩을 하게 되면 컴파일러는 실제 객체의 메소드를 바라보는 것이 아니라. 변수 선언 타입의 메소드를 본다.

Mouse m = new WheelMouse( );

실제 객체가 WheelMouse이지만 컴파일러는 Mouse 타입의 메소드가 정상적으로 호출되고 있는지에만 관심을 두게 된다.

4 인터페이스가 상속보다 다형성에 더욱 유연함을 제공한다.

인터페이스는 클래스의 선언 뒤에서 여러 개의 인터페이스를 구현할 수 있게 할 수 있다. 이런 이유 때문에 하나의 객체를 여러 개의 타입으로 바라보는 다형성에는 상속보다 인터페이스가 더 큰 유연함을 제공한다고 할 수 있다.

cf.) 인터페이스가 여러 개 올 수 있다는 의미는 다시 말해 ‘여러가지 타입으로 변수를 선언할 수 있다’라는 것이다.(인터페이스를 상속과 결부시키지 말고 다형성의 측면에서 이해해야만 한다. 인터페이스는 다중 구현이라는 말이 더 정확하다.)

인터페이스는 그 목적상 기능을 의미하게 할 수 있다. 즉 어떤 객체가 어떤 기능을 할 수 있는가로 설계할 경우에 기능에 초점을 두고 인터페이스로 설계할 수 있다는 얘기이다. 따라서 이렇게 되면 어떤 객체는 여러 가지 기능을 가지게 된다.

결론적으로 인터페이스를 이용하면 하나의 객체가 여러 개의 기능을 가지는 형태로 보이게 만들어줄 수 있다.

마치 상속에서 부모 타입으로 변수를 선언하고 자식 타입으로 객체를 생성하는 코드와 유사하긴 하지만 인터페이스는 더 다양한 형태로 객체를 정의해줄 수 있다. 이것은 마치 부모 클래스의 기능을 물려받는 모습처럼 선언되기는 하지만 상속보다는 더 많은 종류를 보여줄 수 있게 된다. 이런 모습 때문에 일반적으로 다중 상속의 기능을 활용하기 위해서 인터페이스를 사용한다는 설명되는 경우가 많다.

※ 이슈: 다형성을 반영한 참조변수

1) 메서드를 호출한 실제 객체 타입

2) 멤버변수의 실제 객체 타입

class Tv{

boolean power;

int channel;

void power(){ 

power = power;

}

void channelUp(){

++channel;

}

void channelDown(){

--channel;

}

}

class CationTv extends Tv{

String text;//캡션을 보여 주기 위한 문자열

void captionTv(){

...

}

}

Tv t =new Tv();

CationTv e = new CaptionTv();

Tv t =new  CationTv();

CationTv c = new CaptionTv();

Tv t =new CaptionTv();

class CastingTest1 {

public static void main(String args[]) {

Car car = null;

FireEngine fe = new FireEngine();

FireEngine fe2 = null;

fe.water();

car = fe; // car =(Car)fe;에서 형변환이 생략된 형태다.

    // car.water(); // 컴파일 에러!!! Car타입의 참조변수로는 water()를 호출할 수 없다.

fe2 = (FireEngine)car; //자손타입 ← 조상타입

fe2.water();

}

}

class Car {

String color;

int door;

void drive() {// 운전하는 기능

System.out.println("drive, Brrrr~");

}

void stop() {// 멈추는 기능

System.out.println("stop!!!");

}

}

class FireEngine extends Car {// 소방차

void water() {// 물을 뿌리는 기능

System.out.println("water!!!");

}

}

실행결과)

water!!!

water!!!

class CastingTest2 {

public static void main(String args[]) {

Car car = new Car();

Car car2 = null;

FireEngine fe = null;

car.drive();

fe = (FireEngine)car;// 8번째 줄. 실행 시 에러가 발생한다.(조상타입의 인스턴스를 자손타입의 참조변수로 참조하는 것을 허용되지 않는다.--> Child c = new Person();)

fe.drive();

car2 = fe;

car2.drive();

}

}

실행결과)

drive, Brrrr~

java.lang.ClassCastException: Car

at CastingTest2.main(CastingTest2.java:8)

synchronized(객체의 참조변수){

//.....

}

public synchronized void calcSum(){

//.....

}

class ThreadEx24 {

public static void main(String args[]) {

Runnable r = new A();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}

}

class Account {

int balance = 1000;

public void withdraw(int money){

if(balance >= money) {

try { Thread.sleep(1000);} catch(Exception e) {}

balance -= money;

}

} // withdraw

}

class A implements Runnable {

Account acc = new Account();

public void run() {

while(acc.balance > 0) {

// 100, 200, 300중의 한 값을 임으로 선택해서 출금(withdraw)

int money = (int)(Math.random() * 3 + 1) * 100;

acc.withdraw(money);

System.out.println("balance:"+acc.balance);

}

} // run()

}

실행결과)

balance:700

balance:500

balance:200

balance:200

balance:0

balance:-100

class ThreadEx24 {

public static void main(String args[]) {

Runnable r = new A();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}

}

class Account {

int balance = 1000;

public synchronized void withdraw(int money){ //synchronized 키워드를 붙이기만 하면 간단히 동기화가 된다.

if(balance >= money) {

try { Thread.sleep(1000);} catch(Exception e) {}

balance -= money;

}

} // withdraw

}

class A implements Runnable {

Account acc = new Account();

public void run() {

while(acc.balance > 0) {

// 100, 200, 300중의 한 값을 임으로 선택해서 출금(withdraw)

int money = (int)(Math.random() * 3 + 1) * 100;

acc.withdraw(money);

System.out.println("balance:"+acc.balance);

}

} // run()

}

실행결과)

balance:800

balance:700

balance:500

balance:300

balance:100

balance:100

balance:0

balance:0

public void withdraw(int money){

synchronized (this){

if(balance >= money) {

try { Thread.sleep(1000);} catch(Exception e) {}

balance -= money;

}

    }

  }// withdraw()

class K extends Thread {

private int x = 100;

public synchronized void setX(int x) {

this.x += x;

}

public synchronized int getX() { 

return x;

}

public void run() {

synchronized (this) { // 지역 동기화

setX(200);//300 + 200

System.out.println("x = " + getX()); //500

}

}

}

public class Exam_04 {

public static void main(String[] ar) {

K kp = new K();

kp.start();

}

}

실행결과)

x = 300

public synchronized void run() {

// 지역 동기화(특정 범위에 하나의 메서드가 들어있을 경우)

// 지역을 지정하여, setX()나 getX() 메서드 두 가지(동기화 필요한 메서드만)에 대해 동기화를 걸 경우 사용하는 것이다.

synchronized (this) { 

setX(200);

System.out.println("x = " + getX()); 

}

}

1 쓰레드를 생성하고 start()를 호출하면 바로 실행되는 것이 아니라 실행대기열에 저장되어 자신의 차례가 될 때까지 기다려야 한다. 실행대기열은 큐(queue)와 같은 구조로 먼저 실행대기열에 들어온 쓰레드가 먼저 실행된다.

2 실행대기상태에 있다가 자신의 차례가 되면 실행상태가 된다.

3 주어진 실행시간이 다되거나 yeild()를 만나면 다시 실행대기상태가 되고 다음 차례의 쓰레드가 실행상태가 된다.

4 실행 중에 suspecd(), sleep(), wait(), join(), I/O block에 의해 일시정지상태가 될 수 있다. I/O block은 입출력작업에서 발생하는 지연상태를 말한다. 사용자의 입력을 기다리는 경우를 예로 들 수 있는데, 이런 경    우 일시정지 상태에 있다가 사용자가 입력을 마치면 다시 실행대기상태가 된다.

5 지정된 일시정지시간이 다되거나(time-out), notify(), resume(), interrupt()가 호출되면 일시정지 상태를 벗어나 다시 실행대기열에 저장되어 자신의 차례를 기다리게 된다.

6 실행을 모두 마치거나 stop()이 호출되면 쓰레드는 소멸된다.

cf.) 1부터 6까지 번호를 붙였으나 번호의 순서대로 쓰레드가 수행되는 것은 아니다.

class ThreadEx13 {

static long startTime = 0;

public static void main(String args[]) {

A th1 = new A();

B th2 = new B();

th1.start();

th2.start();

startTime = System.currentTimeMillis();

try {

th1.join(); // th1의 작업이 끝날 때까지 기다린다.

th2.join(); // th2의 작업이 끝날 때까지 기다린다.

} catch(InterruptedException e) {}

System.out.print("소요시간:" + (System.currentTimeMillis() - ThreadEx13.startTime));

} // main

}

class A extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("-");

}

} // run()

}

class A extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("|");

}

} // run()

}

실행결과)

------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||소요시간:13

class ThreadEx14 {

public static void main(String args[]) {

A th1 = new A();

  B th2 = new B();

th1.start();

try {

th1.join(); 

  // join(): 두 개 이상의 쓰레드가 동작할 시 하나의 쓰레드에 대해서 지속을 거는 것. 두 개의 쓰레드가 진행하고 있는데 한 쓰레드에 대해서 join 걸면                                           // 그 쓰레드가 끝날때 까지 기다려준다.

  // cf.) sleep()은 전체 쓰레드에 대해 지연을 건다. 하지만 join()은 특정 쓰레드에 대해 지연을 건다.

} catch(InterruptedException e) {}

th2.start();

}

}

class A extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("-");

}

}

}

class B extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("|");

}

}

}

실행결과)

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

/*try {th1.join();} catch(InterruptedException e) {}*/

실행결과)

--|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||------------------------------------------------------------------------------------|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 class ThreadEx15{

public static void main(String args[]) {

A th1 = new A();

B th2 = new B();

th1.start();

th2.start();

try {

th1.sleep(5000);

  // sleep(): 작업 흐름 대기시간 설정한다. 5초동안 대기시간 갖은 후에 다음 문자의 실행흐름을 이어 나간다.

} catch(InterruptedException e) {}

System.out.print("<<main 종료>>");

} // main

}

class A extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("-");

}

System.out.print("<<th1 종료>>");

} // run()

}

class B extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("|");

}

System.out.print("<<th2 종료>>");

} // run()

}

실행결과)

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||||||||||||||||||||||||||||-------------------------------------<<th1 종료>>||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||<<th2 종료>><<main 종료>>

try {Thread.sleep(5000);} catch(InterruptedException e) {}

실행결과)

||||||||||||||||||||||--------------------------|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||----------------|||||||||||||||||||||||--------------------------------------------------------------------------------------------------------------------------|||||||||||||||||||||||||||||||||||||||||||||||||||||||---------------------|||||||||||||||-------------------------------------------------------------------------------<<th2 종료>>------------------------------------<<th1 종료>><<main 종료>>

 class ThreadEx19 {

public static void main(String args[]) {

MyThreadEx19 th1 = new MyThreadEx19("*");

MyThreadEx19 th2 = new MyThreadEx19("**");

MyThreadEx19 th3 = new MyThreadEx19("***");

th1.start();

th2.start();

th3.start();

try {

Thread.sleep(2000);

th1.suspend();

Thread.sleep(2000);

th2.suspend();

Thread.sleep(3000);

th1.resume();

Thread.sleep(3000);

th1.stop();

th2.stop();

Thread.sleep(2000);

th3.stop();

} catch (InterruptedException e) {}

}

}

class MyThreadEx19 implements Runnable {

boolean suspended = false;

boolean stopped = false;

Thread th;

MyThreadEx19(String name) {

th = new Thread(this, name); // Thread(Runnable r, String name)

}

public void run() {

String name = Thread.currentThread().getName();

while(!stopped) {

if(!suspended) {

System.out.println(name);

try {

Thread.sleep(1000);

} catch(InterruptedException e) {

System.out.println(name + " - interrupted");

}

} else {

Thread.yield();

}

}

System.out.println(name + " - stopped");

}

public void suspend() {

suspended = true;

th.interrupt();

// interrupt(): 특정 객체를 멈추고자 할때 사용, 쓰레드의 권한 중지

System.out.println("interrupt() in suspend()");

}

public void resume() {

suspended = false;

}

public void stop() {

stopped = true;

th.interrupt();

System.out.println("interrupt() in stop()");

}

public void start() {

th.start();

}

}

실행결과)

*

**

***

*

**

***

*

interrupt() in suspend()

* - interrupted

***

**

**

***

** - interrupted

interrupt() in suspend()

***

***

***

*

***

*

***

*

***

*

interrupt() in stop()

interrupt() in stop()

* - interrupted

* - stopped

** - stopped

***

***

interrupt() in stop()

*** - interrupted

*** - stopped

boolean isDaemon()  // 쓰레드가 데몬 쓰레드인지 확인한다. 데몬 쓰레드이면 true 반환한다.

void setDaemon(boolean on)  // 쓰레드를 데몬 쓰레드 또는 사용자 쓰레드로 변경한다.(매개변수 on의 값을 true로 지정하면 데몬 쓰레드가 된다.)

import java.util.*;

class example implements Runnable{

    static boolean autoSave = false;

    public static void main(String[] args) {

        Thread t = new Thread(new example());

        t.setDaemon(true); // 이 부분이 없으면 종료되지 않는다.

        // 디폴트: 독립==> setDaemon(true): 데몬쓰레드로 (메인쓰레드 종료시 종속쓰레드는 작업 다 못끝내도 메인 쓰레드와 함께 종료된다.)

        t.start();

        for(int i=1; i<=20; i++)

        {

            try{

                Thread.sleep(1000);

            }catch(InterruptedException e){}

            System.out.println(i);

            if(i==5)

                autoSave = true;

        }

        System.out.println("프로그램을 종료합니다.");

    }

    @Override

    public void run() {

        while(true)

        {

            try{

                Thread.sleep(3 * 1000);

            }catch(InterruptedException e){}

            if(autoSave)

                autoSave();

        }

    }

    private void autoSave() {

        System.out.println("작업파일이 자동저장되었습니다.");

    }

}

실행 결과)

1

2

3

4

5

작업파일이 자동저장되었습니다.

6

7

8

작업파일이 자동저장되었습니다.

9

10

11

작업파일이 자동저장되었습니다.

12

13

14

작업파일이 자동저장되었습니다.

15

16

17

작업파일이 자동저장되었습니다.

18

19

20

프로그램을 종료합니다.

Thread(ThreadGroup group, String name)

Thread(ThreadGroup group, Runnable target)

Thread(ThreadGroup group, Runnable target, String name)

Thread(ThreadGroup group, Runnable target, String name, long stackSize)

static int activeCount()

// 쓰레드 자신이 속한 그룹에 작업이 완료되지 않은 쓰레드 수를 반환한다.

ThreadGroup getThreadGroup()

// 쓰레드 자신이 속한 쓰레드 그룹을 반환한다.

 class ThreadEx10 {

public static void main(String args[]) {

ThreadGroup main = Thread.currentThread().getThreadGroup();

ThreadGroup grp1 = new ThreadGroup("Group1");

ThreadGroup grp2 = new ThreadGroup("Group2");

// ThreadGroup(ThreadGroup parent, String name) 

ThreadGroup subGrp1 = new ThreadGroup(grp1,"SubGroup1"); 

grp1.setMaxPriority(3); // 쓰레드 그룹 grp1의 최대우선순위를 3으로 변경.

// Thread(ThreadGroup tg, String name)

Thread th1 = new Thread(grp1, "th1"); 

// Thread(ThreadGroup tg, String name)

Thread th2 = new Thread(subGrp1, "th2");

// Thread(ThreadGroup tg, String name)

Thread th3 = new Thread(grp2, "th3");   

th1.start();

th2.start();

th3.start();

System.out.println(">>List of ThreadGroup : "+ main.getName() 

  +", Active ThreadGroup: " + main.activeGroupCount()

  +", Active Thread: " + main.activeCount());

main.list();

}

}

실행 결과)

>>List of ThreadGroup : main, Active ThreadGroup : 3, Active Thread : 4

java.lang.ThreadGroup[name=main,maxpri=10]

    Thread[main,5,main]

    java.lang.ThreadGroup[name=Group1,maxpri=3]

        Thread[th1,3,Group1]

        java.lang.ThreadGroup[name=SubGroup1,maxpri=3]

            Thread[th2,3,SubGroup1]

    java.lang.ThreadGroup[name=Group2,maxpri=10]

void setPriority(int newPriority): 쓰레드의 우선순위를 지정한 값으로 변경한다.

int getPriority(): 쓰레드의 우선순위를 반환한다.

public static final int MAX_PRIORITY = 10 // 최대 우선 순위

public static final int MIN_PRIORITY = 1 // 최소 우선 순위

public static final int NORM_PRIORITY = 5 //보통 우선 순위

class ThreadPriority {

public static void main(String args[]) {

A th1 = new A();

B th2 = new B();

th1.setPriority(4); // defalut 우선순위 5

th2.setPriority(7);

System.out.println("Priority of th1(-) : " + th1.getPriority() );

System.out.println("Priority of th2(|) : " + th2.getPriority() );

th1.start();

th2.start();

}

}

class A extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("-");

for(int x=0; x < 10000000; x++);

}

}

}

class B extends Thread {

public void run() {

for(int i=0; i < 300; i++) {

System.out.print("|");

for(int x=0; x < 10000000; x++);

}

}

}

실행결과)

Priority of th1(-) : 4

Priority of th2(|) : 7

-||-||-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||