'java'에 해당되는 글 16건

  1. 2017.04.18 [Java] Array Value 존재 유무 확인하기
  2. 2017.01.16 [Intellij] intellij-java-google-style.xml 적용하기
  3. 2017.01.09 [Gradle] Gradle project 맛보기.
  4. 2016.12.19 [웹 크롤러] crawler4j 링크
  5. 2016.11.09 [Java] String[] to List, List dedup. List to String comma
  6. 2016.04.11 [Java] Build Executable Jar + Local Dependency Jar on Intellij
  7. 2016.03.03 [Java] 외부 프라퍼티(XML) 파일 설정 정보 읽기
  8. 2015.12.05 [JAVA] executable jar 생성 시 pom.xml build 설정.
  9. 2013.04.09 [java] java.util.concurrent.* 링크
  10. 2013.04.05 java system properties...

[Java] Array Value 존재 유무 확인하기

ITWeb/개발일반 2017.04.18 10:38

생각 나지 않을때가 많아서 퍼왔습니다.


Originanl Source)

http://www.programcreek.com/2014/04/check-if-array-contains-a-value-java/


public static boolean useList(String[] arr, String targetValue) {

  return Arrays.asList(arr).contains(targetValue);

}


public static boolean useSet(String[] arr, String targetValue) {

  Set<String> set = new HashSet<String>(Arrays.asList(arr));

  return set.contains(targetValue);

}


public static boolean useLoop(String[] arr, String targetValue) {

  for(String s: arr){

    if(s.equals(targetValue))

      return true;

  }

  return false;

}


public static boolean useArraysBinarySearch(String[] arr, String targetValue) { 

  int a =  Arrays.binarySearch(arr, targetValue);

  if(a > 0)

    return true;

  else

    return false;

}


binary search 가 제일 성능이 좋습니다.

단, 위 코드에서 빠진게 있다면 Arrays.sort(arr) 를 먼저 하고 하셔야 된다는 것입니다.


Arrays.sort(arr);

int a = Arrays.binarySearch(arr, targetValue);

저작자 표시 비영리 변경 금지
신고
Trackback 0 : Comment 0

[Intellij] intellij-java-google-style.xml 적용하기

ITWeb/개발일반 2017.01.16 15:42

각자 필요한 코드 스타일은 아래서 다운로드 받으시면 됩니다.


[구글 코드 스타일]

https://github.com/google/styleguide


[Intellij 적용하기 - mac]

# 저는 intellij 2016.3 사용중입니다.

# 다운로드 받으신 intellij-java-google-style.xml 파일을 아래 경로로 복사해서 넣습니다.


$ cd ~/Library/Preferences/IntelliJIdea2016.3/codestyles


[Intellij 에서 import 하기]

Preferences -> Editor -> Code Style -> Manage Button -> Import


# 그러나 파일을 먼저 복사해 넣었기 때문에 import 하지 않으셔도 scheme 이 정상적으로 나옵니다.

# Scheme 을 GoogleStyle 로 변경 하시면 끝납니다.


저작자 표시 비영리 변경 금지
신고
Trackback 0 : Comment 0

[Gradle] Gradle project 맛보기.

ITWeb/개발일반 2017.01.09 13:46

Intellij 를 이용한 gradle project 를 생성하는 아주 초보적인 내용입니다.

개인적인 생각으로는 single project 이고 maven 에 익숙하시면 그냥 maven project 로 개발 하시는게 편하실 수 있습니다.


Step 0)

- Gradle 설치가 되어 있어야 합니다.

- Java 설치가 되어 있어야 합니다.

- Path 설정이 되어 있어야 합니다.


Step 1)

New -> Project -> Gradle 선택을 하시면 됩니다.


Step 2)

maven project 생성 할 때와 동일하게 GroupId, ArtifactId, Version 정보를 등록 하면 됩니다.


Next 버튼을 누르고 누르고 나면 기본 Gradle Project 가 생성이 됩니다.


Step 3) build.gradle & settings.gradle

기본적인 빌드 환경과 정보들을 작성 하게 됩니다.

maven 의 pom.xml 과 비슷하다고 보시면 될 것 같습니다.


Step 4) module 추가하기

해당 프로젝트에서 new -> module 하시면 됩니다.

동일하게 gradle project 으로 해서 추가했습니다.


Step 5) 기본 java application directory 생성

src/main/java

src/main/resources

src/test/java

src/test/resources


Step 6) Java main class 생성

public class HelloWorld {

public static void main (String[] args) {
System.out.println("Hello World!!");
}
}


Step 7) Build & Run

$ gradle build


$ java -jar ./helloworld/build/libs/helloworld-1.0-SNAPSHOT.jar HelloWorld

./helloworld/build/libs/helloworld-1.0-SNAPSHOT.jar에 기본 Manifest 속성이 없습니다.


# manifest 속성을 선언 안해서 그렇습니다.
해당 프로젝트의 build.gradle 에 선언 하면 됩니다.
excutable jar 생성 하는 거랑 같은 거라고 보시면 됩니다.
jar {
manifest {
attributes 'Main-Class': 'org.jjeong93.hello.HelloWorld'
}
}

$ java -jar ./helloworld/build/libs/helloworld-1.0-SNAPSHOT.jar HelloWorld

Hello World!!


일반적인 Java application 만드는 걸 예제로 보여 드렸습니다.
저는 기존 maven project 를 gradle multi project 로 마이그레이션 하려고 합니다.
dependency 설정 하는 번거로움이 좀 있기는 하지만 마이그레이션 방법을 제공 하고 있으니 참고 하면 될 것 같습니다.

[참고문서]


저작자 표시 비영리 변경 금지
신고
tags : gradle, java, maven
Trackback 0 : Comment 0

[웹 크롤러] crawler4j 링크

ITWeb/개발일반 2016.12.19 13:17

웹 크롤러가 많이 있습니다.

그 중에서 그냥 java 로 쉽게 구현 할 수 있는 crawler4j 링크 공유해 봅니다.


https://github.com/yasserg/crawler4j


샘플 코드는 그냥 위 링크에 올라와 있는 코드 그대로 테스트 해보시면 동작 잘 합니다.

robots.txt 에러가 발생 하는 부분이 있을 경우 아래 설정 추가해 주시면 됩니다.


RobotstxtConfig robotstxtConfig = new RobotstxtConfig();
robotstxtConfig.setEnabled(false);


다른 크롤러가 궁금하신 분들은 아래 구글링 링크 참고하세요.

https://www.google.co.kr/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#newwindow=1&q=web+crawler+open+source


저작자 표시 비영리 변경 금지
신고
Trackback 0 : Comment 0

[Java] String[] to List, List dedup. List to String comma

ITWeb/개발일반 2016.11.09 12:42

이젠 뭘 해도 기억력이 따라오질 못합니다. ㅠ.ㅠ

복습을 위해서.


Stirng[] to List)

String[] keywords = {"기어", "s3", "기어"};

List<String> lists = Arrays.asList(keywords);


List DeDup)

HashSet<String> set = new HashSet<>(lists);

List<String> result = new ArrayList<>(set);


List to String comma)

StringUtils.join(result, ',');


저작자 표시 비영리 변경 금지
신고
tags : dedup, java, list, string[]
Trackback 0 : Comment 0

[Java] Build Executable Jar + Local Dependency Jar on Intellij

ITWeb/개발일반 2016.04.11 19:09

예전 글에 일부 설명이 있는데 오늘 삽질한 내용으로 기록해 봅니다.


local 에서 systemPath를 이용해서 dependency 를 설정해 준 경우 manifest 파일에 classpath 로 등록이 되지 않는 문제였습니다.

해결 방법은 아래 코드에 <manifestEntries />를 이용해서 추가해 주었습니다.


<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.4</version>
<configuration>
<archive>
<index>false</index>
<manifestEntries>
<Class-Path>lib/system-path-jar-0.0.1.jar</Class-Path>
</manifestEntries>
<manifest>
<addClasspath>true</addClasspath>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>MainClass</mainClass>
</manifest>
</archive>
</configuration>
</plugin>


아래 글 참고해서 보세요.

  1. 2015.12.05 [JAVA] executable jar 생성 시 pom.xml build 설정.
  2. 2015.09.22 [Maven] Executable jar + Assembly 를 이용한 tar 묶기.


저작자 표시 비영리 변경 금지
신고
Trackback 0 : Comment 0

[Java] 외부 프라퍼티(XML) 파일 설정 정보 읽기

ITWeb/개발일반 2016.03.03 16:30

외부에 존재하는 properties 파일이나 xml 파일에서 설정 정보를 읽고 싶을 경우가 있습니다.

그래서 기록해 봅니다.


import java.io.*;

import java.util.Properties;


Properties properties = new Properties();

InputStreamReader isr = null;


try {

  isr = new InputStreamReader(new FileInputStream("/server/config/config.properties"), "UTF-8");

  properties.load(isr);

} finally {

  if (null != isr) {

    try {

      isr.close();

    } catch (IOException ex) {}

  }

}


System.out.println(properties.getProperty("프라퍼티명"));


xml을 읽고 싶을 경우 

properties.loadFromXML(InputStream in);

을 이용하시면 됩니다.


저작자 표시 비영리 변경 금지
신고
Trackback 0 : Comment 0

[JAVA] executable jar 생성 시 pom.xml build 설정.

ITWeb/개발일반 2015.12.05 20:40

맨날 잊어버리기 때문에 별거 아니지만 그냥 기록 합니다.


아래 설정은 executable jar 를 만들때 필요한 dependency jar 와 classpath 를 함께 구성해 주기 위해서 사용을 합니다.

자세한 내용은 링크 참고 하시면 됩니다.


[Apache Maven Archiver Examples Classpath]


[build property example]

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
<encoding>${project.build.sourceEncoding}</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<includeScope>compile</includeScope>
<outputDirectory>${project.build.directory}/lib</outputDirectory>
<overWriteReleases>false</overWriteReleases>
<overWriteSnapshots>false</overWriteSnapshots>
<overWriteIfNewer>true</overWriteIfNewer>
</configuration>
</execution>
</executions>
</plugin>

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.4</version>
<configuration>
<archive>
<index>false</index>
<manifest>
<addClasspath>true</addClasspath>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>MainClass</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
<pluginManagement>
<plugins>
<!-- Ignore/Execute plugin execution -->
<plugin>
<groupId>org.eclipse.m2e</groupId>
<artifactId>lifecycle-mapping</artifactId>
<version>1.0.0</version>
<configuration>
<lifecycleMappingMetadata>
<pluginExecutions>
<!-- copy-dependency plugin -->
<pluginExecution>
<pluginExecutionFilter>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<versionRange>[1.0.0,)</versionRange>
<goals>
<goal>copy-dependencies</goal>
</goals>
</pluginExecutionFilter>
<action>
<ignore />
</action>
</pluginExecution>
</pluginExecutions>
</lifecycleMappingMetadata>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>


저작자 표시 비영리 변경 금지
신고
Trackback 0 : Comment 0

[java] java.util.concurrent.* 링크

ITWeb/개발일반 2013.04.09 10:28

[원본글] http://blog.naver.com/windziel?Redirect=Log&logNo=60058329824


java.util.concurrent 패키지는 자바 1.5에 추가된 패키지로서 concurrent 프로그래밍에 유용한 클래스들을 모아둔 것이다.

그중 유용한 것들을 몇가지 정리

참고 - 자바 언어로 배우는 디자인 패턴 입문 멀티 쓰레드 편 - 유키 히로시

 

java.util.concurrent.Semaphore  클래스

사용할 수 있는 리소스의 수가 최대 N개인데 N개보다 많은 수의 쓰레드가 그 리소스를 필요로 하는 경우 Semaphore를 이용하여 리소스 사용을 제어한다.

 

생서자에서 리소스의 수(permits)를 지정

acquire() - 리소스를 확보. 리소스에 빈자리가 생겼을 경우 바로 쓰레드가 acquire 메소드로부터 곧바로 돌아오게 되고 세마포어 내부에서는

                      리소스의 수가 하나 감소. 리소스에 빈자리가 없을 경우 쓰레드는 acquire 메소드 내부에서 블록.
release() - 리소스를 해제. 세마포어 내부에서는 리소스가 하나 증가. acquire 메소드 안에서 대기중인 쓰레드가 있으면

                      그 중 한 개가 깨어나 acquire 메소드로부터 돌아올 수 있다.

 

<예제>

import java.util.Random;

import java.util.concurrent.Semaphore;

/**
 * 수 제한이 있는 리소스
 */
class BoundedResource {
    private final Semaphore semaphore;
    private final int permits;
    private final static Random random = new Random(314159);
    
    public BoundedResource(int permits) {
        this.semaphore = new Semaphore(permits);
        this.permits = permits;
    }
    
    public void use() throws InterruptedException {
        semaphore.acquire();
        
        try {
            doUse();
        } finally {
            semaphore.release();
        }
    }
    
    protected void doUse() throws InterruptedException {
        System.out.println("BEGIN: used = " + (permits - semaphore.availablePermits()));
        Thread.sleep(random.nextInt(500));
        System.out.println("END: used = " + (permits - semaphore.availablePermits()));
    }
}


/**
 * 리소스를 사용하는 쓰레드
 */
class UserThread extends Thread {
    private final static Random random = new Random(26535);
    private final BoundedResource resource;
    
    public void run() {
        try {
            while (true) {
                resource.use();
                Thread.sleep(random.nextInt(3000));
            }
        } catch (InterruptedException e) {
        
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 3개의 리소스 준비
        BoundedResource resource = new BoundedResource(3);
        
        // 10개의 쓰레드가 사용
        for (int i = 0; i < 10; i++) {
            new UserThread(resource).start();
        }
    }
}

 

java.util.concurrent.locks 패키지의 ReadWriteLock 인터페이스와 ReentrantReadWriteLock 클래스

인스턴스 생성시 락의 취득 순서를 공평(fair)하게 할 것인지를 선택할 수 있다.
공평한 인스턴스를 만든 경우, 대기시간이 긴 쓰레드가 최우선적으로 락을 취득할 수 있도록 조정된다.
재입장 가능하다. 즉, 읽기 역할의 쓰레드가 쓰기 위한 락을 취하거나, 쓰기 역할의 쓰레드가 읽기 위한 락을 취하는 것이 가능하다.
쓰기 위한 락을 읽기 위한 락으로 다운그레이드 할 수 있다. 반대는 안된다.

 

<예제>

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Data {
    private final char[] buffer;
    private final ReadWriteLock lock = new ReentrantReadWriteLock(ture /* fair */);
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();
    
    public Data(int size) {
        this.buffer = new char[size];
        
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = '*';
        }
    }
    
    public char[] read() throws InterruptedException {
        readLock.lock();
        try {
            return doRead();
        } finally {
            readLock.unlock();
        }
    }
    
    public void write(char c) throws InterruptedException {
        writeLock.lock();
        try {
            return doWrite(c);
        } finally {
            writeLock.unlock();
        }
    }
    
    private char[] doRead() {
        char[] newbuf = new char[buffer.length];
        
        for (int i = 0; i < buffer.length; i++) {
            newbuf[i] = buffer[i];
        }
        slowly();
        return newbuf;
    }
    
    private void doWrite(char c) {
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = c;
            slowly();
        }
    }
    
    private void slowly() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
        }
    }
}

import java.util.Random;

public class WriterThread extends Thread {
    private static final Random random = new Random();
    private final Data data;
    private final String filter;
    private int index = 0;
    
    public WriterThread(Data data, String filter) {
        this.data = data;
        this.filter = filter;
    }
    
    public void run() {
        try {
            while (true) {
                char c = nextchar();
                data.write(c);
                Thread.sleep(random.nextInt(3000));
            }
        } catch (InterruptedException e) {
        
        }
    }
    
    private char nextchar() {
        char c = filter.charAt(index);
        index++;
        if (index >= filter.length()) {
            index = 0;
        }
        
        return c;
    }
}

public class ReaderThread extends Thread {
    private final Data data;
    
    public ReaderThread(Data data) {
        this.data = data;
    }
    
    public void run() {
        try {
            while (true) {
                char[] readbuf = data.read();
                System.out.println(Thread.currentThread().getName() + " reads "
                    + String.valueOf(readbuf));
            }
        } catch (InterruptedException e) {
        
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Data data = new Data(10);
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new ReaderThread(data).start();
        new WriterThread(data, "ABCDEFGHIJKLMNOPQRSTUVWXYZ").start();
        new WriterThread(data, "abcdefghijklmnopqrstuvwxyz").start();
    }
}

 

 

java.util.concurrent.ThreadFactory 인터페이스

쓰레드 생성을 추상화한 인터페이스

Thread newThread(Runnable r);

ThreadFactory 인터페이스를 구현한 객체를 바꾸는 것 만으로 쓰레드의 생성을 제어
간단한 구현에서는 이것을 사용할 필요없이 Executors.defaultThreadFactory()를 사용하여 기본 ThreadFactory를 구할수 있다.

 

java.util.concurrent.Executor 인터페이스

void execute(Runnable r);

어떤 "처리를 실행"하는 것을 추상화한 인터페이스이며 인수로 부여되는 Runnable 객체는 "실행하는 처리"의 내용을 나타낸다.

 

java.util.concurrent.ExecutorService 인터페이스

반복하여 execute할 수 있는 서비스를 추상화
배후에서 쓰레드가 항상 동작하고 있고 execute 메소드를 호출하면 Runnable 객체를 실행해 주는 것이라고 생각하면 됨.
서비스 종료용으로 shutdown() 메소드 제공

Executor의 서브 인터페이스임

보통 Executors 클래스의 유틸리티 메소드중 ExecutorService 타입을 리턴하는 메소드들을 이용하여 ExecutorService를 얻어 사용

 

java.util.concurrent.ScheduledExecutorService 인터페이스

ExecutorService의 서브 인터페이스이며 처리의 실행을 지연시키는 기능

schedule(Runnable r, long delay, TimeUnit unit);

delay는 지연시간의 수치이며, unit는 delay수치의 단위(NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS)를 지정
Executors.newScheduledThreadPool() 메소드에 의해 ScheduledExecutorService 객체를 생성하여 사용.

 

java.util.concurrent.Executors 클래스

위의 인터페이스 등을 생성시 사용하는 유틸리티 클래스

 

java.util.concurrent.ThreadPoolExecutor 클래스

쓰레드 풀에 대해 아래와 같은 설정을 할 수 있다.
 - 쓰레드풀의 크기
 - 쓰레드를 미리 생성할 것인지 필요에 따라 생성할 것인지
 - 쓰레드를 생성할 때의 팩토리(java.util.concurrent.ThreadFactory)
 - 필요 없어진 워커 쓰레드를 종료시키기까지의 시간
 - 실행하는 일을 건넬 때의 큐인 방법
 - 실행을 거부하는 방법
 - 실행의 전처리, 후처리
 
이 클래스는 ExecutorService를 구현한 것으로 보통은 Executors 클래스에 준비되어 있는 메소드를 사용하는 것이 편리.

Executors.newCachedThreadPool(), Executors.newFixedThreadPool() 등

세세한 설정이 필요한 경우 직접 생성

 

java.util.concurrent.Callable 인터페이스

반환값이 있는 처리의 호출을 추상화
Runnable 인터페이스의 run 메소드와 비슷하지만 반환값이 있다.
Callable<String>라고 기술하면 call 메소드의 반환값의 형이 String인 Callable 인터페이스를 나타낸다.


java.util.concurrent.Future 인터페이스

값을 취득하는 get 메소드가 선언
Future<String>라고 기술하면 get 메소드의 반환값이 String인 Future 인터페이스를 나타낸다.


java.util.concurrent.FutureTask 클래스

Future 인터페이스를 구현한 표준적인 클래스
값을 취득하는 get()
실행을 중단하는 cancel()
값을 설정하는 set()
예외를 설정하는 setException()
Runnable 인터페이스를 구현하고 있으므로 run()

생성자의 인수에 Callable 객체를 건내고 FutureTask의 run 메소드를 호출하면 생성자의 인수로 건넨 Callable 객체의 call 메소드가 실행된다. call 메소드를 호출한 쓰레드는 call 메소드의 반환값을 동기적으로 구하고 그 반환값을 FutureTask의 set 메소드롤 설정한다. 만약 call 메소드에서 예외가 발생하면 FutureTask의 setException 메소드를 사용하여 예외를 설정한다. 필요에 따라 get 메소드로 값을 취하러 가면 call 메소드의 반환값을 구할 수 있다.

 

java.util.concurrent.CountDownLatch 클래스

지정한 회수만큼 countdown 메소드가 호출되기를 기다린다.

 

<예제>

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.CountDownLatch;

public class Main {
    private static final int TASKS = 10;
    
    public static void main(String[] args) {
        System.out.println("BEGIN");
        ExecutorService service = Executors.newFixedThreadPool(5);
        CountDownLatch doneLatch = new CountDownLatch(TASKS);
        
        try {
            for (int i = 0; i < TASKS; i++) {
                service.execute(new MyTask(doneLatch, i));
            }
            System.out.println("AWAIT");
            
            doneLatch.await();
        } catch (InterruptedException e) {
        
        } finally {
            service.shutdown();
            System.out.println("END");
        }
    }
}


import java.util.Random;

import java.util.concurrent.CountDownLatch;

public class MyTask implements Runnable {

    private final CountDownLatch donLatch;
    private final int context;
    private static final Random random = new Random(314159);
    
    public MyTask(CountDownLatch doneLatch, int context) {
        this.doneLatch = doneLatch;
        this.context = context;
    }
    
    public void run() {
        doTask();
        doneLatch.countDown();
    }
    
    protected void doTask() {
        String name = Thread.currentThread().getName();
        System.out.println(name + ":MyTask:BEGIN:context = " + context);
        try {
            Thread.sleep(random.nextInt(3000));
        } catch (InterruptedException e) {
        
        } finally {
            System.out.println(name + ":MyTask:END:context = " + context);
        }
    }
}

 

위의 인터페이스, 클래스들 외에도 멀티 쓰레드 프로그램에서 안전하게 사용할 수 있는 자료구조에 대한 인터페이스 및 이를 구현한 클래스들이 있다.

BlockingQueue, BlockingDeque ConcurrentMap 등의 인터페이스를 구현한 클래스들이 있으므로 필요에 따라 가져다 사용하면 된다.

 

장황하게 많은 인터페이스, 클래스들을 설명했지만 자주 사용할 만한 것은

Executors 유틸리티 클래스를 이용해서 단일 쓰레드의 경우 newSingleThreadExecutor(), 쓰레드풀의 경우 newFixedThreadPool() 또는 newCachedThreadPool() 메소드를 이용하여 ExecutorService의 인스턴스를 획득한 후 Runnable을 구현한 클래스를 execute() 메소드에 넘겨주어 시작하고, shutdown() 또는 shutdownNow() 메소드를 사용하여 중지시키는 정도로 사용하면 될 듯하다.

 

<예제 - from JDK API Document>

class NetworkService implements Runnable {
   private final ServerSocket serverSocket;
   private final ExecutorService pool;

   public NetworkService(int port, int poolSize)
       throws IOException {
     serverSocket = new ServerSocket(port);
     pool = Executors.newFixedThreadPool(poolSize);
   }

   public void run() { // run the service
     try {
       for (;;) {
         pool.execute(new Handler(serverSocket.accept()));
       }
     } catch (IOException ex) {
       pool.shutdown();
     }
   }
 }

 class Handler implements Runnable {
   private final Socket socket;
   Handler(Socket socket) { this.socket = socket; }
   public void run() {
     // read and service request on socket
   }
 }

 void shutdownAndAwaitTermination(ExecutorService pool) {
   pool.shutdown(); // Disable new tasks from being submitted
   try {
     // Wait a while for existing tasks to terminate
     if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
       pool.shutdownNow(); // Cancel currently executing tasks
       // Wait a while for tasks to respond to being cancelled
       if (!pool.awaitTermination(60, TimeUnit.SECONDS))
           System.err.println("Pool did not terminate");
     }
   } catch (InterruptedException ie) {
     // (Re-)Cancel if current thread also interrupted
     pool.shutdownNow();
     // Preserve interrupt status
     Thread.currentThread().interrupt();
   }
 }

신고

'ITWeb > 개발일반' 카테고리의 다른 글

[JSONObject] Maven Dependency 설정  (0) 2013.05.07
[Maven] pom.xml <scope> 설명.  (0) 2013.05.03
[java] java.util.concurrent.* 링크  (0) 2013.04.09
[java] junit thread testing.  (0) 2013.04.08
[java] read properties or xml file.  (0) 2013.04.05
java system properties...  (0) 2013.04.05
tags : concurrent, java
Trackback 0 : Comment 0

java system properties...

ITWeb/개발일반 2013.04.05 10:42

http://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html


KeyMeaning
"file.separator"Character that separates components of a file path. This is "/" on UNIX and "\" on Windows.
"java.class.path"Path used to find directories and JAR archives containing class files. Elements of the class path are separated by a platform-specific character specified in the path.separator property.
"java.home"Installation directory for Java Runtime Environment (JRE)
"java.vendor"JRE vendor name
"java.vendor.url"JRE vendor URL
"java.version"JRE version number
"line.separator"Sequence used by operating system to separate lines in text files
"os.arch"Operating system architecture
"os.name"Operating system name
"os.version"Operating system version
"path.separator"Path separator character used in java.class.path
"user.dir"User working directory
"user.home"User home directory
"user.name"User account name

신고

'ITWeb > 개발일반' 카테고리의 다른 글

[java] junit thread testing.  (0) 2013.04.08
[java] read properties or xml file.  (0) 2013.04.05
java system properties...  (0) 2013.04.05
vim에서 개행문자 삽입하기.  (0) 2013.04.03
jetty turotial  (0) 2013.04.03
@override annotation error by jdk 1.5  (0) 2013.04.03
Trackback 0 : Comment 0