public static float arr2float (byte[] arr, int start) {

            int i = 0;
            int len = 4;
            int cnt = 0;
            byte[] tmp = new byte[len];

            for (i = start; i < (start + len); i++) {
                  tmp[cnt] = arr[i];
                  cnt++;
            }

            int accum = 0;
            i = 0;
            for ( int shiftBy = 0; shiftBy < 32; shiftBy += 8 ) {
                  accum |= ( (long)( tmp[i] & 0xff ) ) << shiftBy;
                  i++;
            }
            return Float.intBitsToFloat(accum);
}    

Posted by 짱가쟁이
public static int byteToShort(byte[] bytes) {
     
            int newValue = 0;
            newValue |= (((int)bytes[0])<<8)&0xFF00;
            newValue |= (((int)bytes[1]))&0xFF;

            return newValue;
}

Posted by 짱가쟁이
텔레메트릭스 어쩌구 하면서 IEEE1451 TEDS Tool을 작업하면서 XML로 TEDS 데이터를 관리한적이 있었다.

그당시 JDOM(??)을 사용했을듯 한데.. 하튼.. 아무 생각없이 좀 무식하게 만들감이 있어.. XML to Object 를 찾다가 발견한넘이 JAXB(Java Architecture for XML Binding)다. 생각보다 요넘 많이 유용한듯..

문서를 찾다보니.. 예외 처리 시 어쩌구 저쩌구 하지만.. 그 방법은 다음으로 미루고.. 초기 프로토타입 버전을 올림(난중에 얼마나 무식했었는지 참고용ㅋㅋ)

Example
package jface.common.xmlbind;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.UnmarshallerHandler;

import javax.xml.bind.Unmarshaller;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;

import jface.common.coolbar.marshalling.Coolbar;

public class XmlBinding {

 

 /**
  * unmarshalling
  *
  * XML to java 데이터 객체
  *
  * @param path
  *    .xml 경로
  * @return
  *    언마샬된 데이터 객체
  */
 public Coolbar getCoolBarMenu(String path) {
 
  try {
   ClassLoader cl = this.getClass().getClassLoader();
   JAXBContext context   = JAXBContext.newInstance(Coolbar.class); 
   Unmarshaller unmarshaller  = context.createUnmarshaller();
  
   // Unmarshaller에서 저수준 처리기를 얻는다.
   UnmarshallerHandler unmarshallerHandler = unmarshaller.getUnmarshallerHandler();

   // SAX 파서를 얻기 위해 JAXP를 사용한다.
   SAXParserFactory factory = SAXParserFactory.newInstance();

   // factory 옵션을 설정한 다음, 표준 JAXP 호출을 사용한다.
   factory.setNamespaceAware(true);

  
   XMLReader reader = factory.newSAXParser().getXMLReader();

   // unmarshallerHandler로 reader 처리기를 설정한다.
   reader.setContentHandler(unmarshallerHandler);

   // 이제 JAXB에서 가져온 언마샬링 처리기를 사용해 구문분석에 들어간다.
   reader.parse(new InputSource(cl.getResourceAsStream(path)));
  
   Coolbar instance = (Coolbar)unmarshallerHandler.getResult();

   return instance;
  } catch(Exception e) {
   e.printStackTrace();
   return null;
  }

 }
 
 /**
  * marshalling
  *
  * java object to XML
  * @param path
  *     .xml 경로
  * @param coolbar
  *     java 데이터 객체
  */
 public void setCoolBarMenu(String path, Coolbar coolbar) {
  try {
   ClassLoader cl = this.getClass().getClassLoader();
   JAXBContext jc = JAXBContext.newInstance(Coolbar.class);
  
         Marshaller   m  = jc.createMarshaller();
         m.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT,  Boolean.TRUE );

         OutputStream  os  = new FileOutputStream( new File(cl.getResource(path).getPath()) );

         m.marshal( coolbar, os );


  } catch(Exception e) {
  }
 }
}

ps.
    - XML to Java Class 를 이클립스 plug in 으로 만들어 보는게 좋을듯.. 공부도 할겸. (이런거는 좀 미루지 말자.)


'java > xml' 카테고리의 다른 글

[xml] - xjc.exe 를 사용한 xsd to java class 생성  (0) 2010.06.29
[xml] - xml to xsd  (0) 2010.06.29
[java] - Marshaller 을 이용한 Object to xml string  (0) 2010.06.25
Posted by 짱가쟁이
xjc.exe
C:\Program Files\Java\jdk1.6.0_16\bin\xjc.exe

사용방법
D:\Launcher>xjc XCoolBar.xsd
parsing a schema...
compiling a schema...
generated\Child.java
generated\Coolbar.java
generated\ObjectFactory.java
generated\Parent.java

'java > xml' 카테고리의 다른 글

[JAXB] - unmarshalling, marshalling  (0) 2010.06.29
[xml] - xml to xsd  (0) 2010.06.29
[java] - Marshaller 을 이용한 Object to xml string  (0) 2010.06.25
Posted by 짱가쟁이
2010. 6. 29. 17:16

작성된 *.xml을 토대로 OOO.xsd 생성

- Trang(XSD 추론도구)를 사용하여 XSD 생성.
- Trang 사용 예.
    : java -jar trang.jar coolbar.xml XCoolBar.xsd

Posted by 짱가쟁이
Java Performance Fundamental 40page 를 보면 알기 쉽게 설명해 놓음.
 

붕어빵틀(Class)과 붕어빵 관계(Instance)
위의 책을 토대로 설명하면.. Class Loading 시 Class 정보를 추출하여 Method Area 에 붕어빵틀을 생성한다. 여기서 누군가가 Instance를 생성할려고 하면 Method Area 의 Class 정보를 틀로 하여 Heap 에 Object를 하나 찍어낸다. 이것이 Instance 이다.

Posted by 짱가쟁이
참조
Java Performance Fundamental(김한도) 참조

Field
- Instance Variable
  : non-static field

- Class Variable     
  : Class 에서 static 으로 선언된 변수(static field) 이며 Class 에서는 하나의 값으로 유지됨
  : Class 를 사용하기 전부터 Method Area 에 미리 메모리를 할당 받는다.

Variable
- Local Variable
- Parameter

Posted by 짱가쟁이
java.util.concurrent.locks.Condition
- 하나의 락에 여러 조건으로 대기하게 할 수 있다. (예제 참고)
- 인터럽트에 반응하거나 반응하지 않은 대기 상태를 만들수 있다.
- 데드라인을 정해둔 대기 상태를 만들 수 있다.
package java.util.concurrent.locks;

import java.util.concurrent.*;
import java.util.Date;

public interface Condition {
    void await() throws InterruptedException;
    void awaitUninterruptibly();
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    boolean awaitUntil(Date deadline) throws InterruptedException;
    void signal();
    void signalAll();
}

예제
java api 참조

Condition 객체를 활용하여 put(), take() 에 조건별로 나눠서 대기하기 때문에 siganlAll() 대신 더 효율적인 signal() 을 사용할 수 있게 되었다. 뭐 java api 내용을 보면 ArrayBlockingQueue 에서 이 기능을 하기 때문에 따로 구현하지 말라고 나오기는 함 ㅋㅋ
package study.lock.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class BoundedBuffer<T> {
 final Lock   lock   = new ReentrantLock();
 final Condition notFull  = lock.newCondition();
 final Condition notEmpty = lock.newCondition();
 final T[]   items   = (T[]) new Object[100];
 int tail, head, count;

 public void put(T x) throws InterruptedException {
  lock.lock();
  try {
   while (count == items.length)
    notFull.await();
   items[tail] = x;
   if (++tail == items.length) tail = 0;
   ++count;
   notEmpty.signal();
  } finally {
   lock.unlock();
  }
 }

 public Object take() throws InterruptedException {
  lock.lock();
  try {
   while (count == 0)
    notEmpty.await();
   Object x = items[head];
   if (++head == items.length) head = 0;
   --count;
   notFull.signal();
   return x;
  } finally {
   lock.unlock();
  }
 }
}

참고
- java api
- java concurrency in practice
Posted by 짱가쟁이
1. LockSample.java
- 인터럽트 요청이 올때까지 무식하게 자원만 축내는 넘..
package study.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockSample {

 final Lock lock = new ReentrantLock();
 
 public static Thread thread;
 
 public void lockTest() throws InterruptedException {
 
  if(!lock.tryLock(1, TimeUnit.SECONDS)) {
   System.out.println(Thread.currentThread().getName() + " : 누군가가 선점하고 있다.");
   return;
  }
 
  thread = Thread.currentThread();
 
  System.out.println(Thread.currentThread().getName() + " : 내가 선점하고 있다.");
 
  try {
     // 락을 인터럽트 시킬수 있다.
     lock.lockInterruptibly();
    
   try {
      // critical section
    Thread.sleep(6000);
     } finally {
      // 획 해제
      lock.unlock();
     }
   } catch (InterruptedException e) {
    // 인터럽트 됨.
  
    throw new InterruptedException(Thread.currentThread().getName() + " : 인터럽트 당함");
   }  finally {
    lock.unlock();
   }
 }
}

2. Task.java
- 무식하게 일만 시키는넘
package study.lock;


public class Task extends Thread {
 
 final LockSample sample;
 
 public Task(String name, final LockSample sample) {
  super(name);
  this.sample = sample;
 }
 
 public void run() {

  while(!isInterrupted())  {
   try {

    sample.lockTest();
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    return;
   }
  }
 }
}

3. 테스트
final LockSample sample = new LockSample();
 
Task task = new Task("task1", sample);
task.start();

Task task1 = new Task("task2", sample);
task1.start();

try {
 Thread.sleep(5000);
} catch (InterruptedException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
}

LockSample.thread.interrupt();

4. 결과
- 한놈이 계속 자원을 사용하고 있으면 다른 한놈은 다른 놈이 자원을 사용하고 있다고 울부짓는다. 중간에 인터럽트를 발생시키면 못먹겠다고 울부짖던 놈이 이번엔 지가 처먹는다. 굉장히 단순한넘인디..
task2 : 내가 선점하고 있다.
task1 : 누군가가 선점하고 있다.
task1 : 누군가가 선점하고 있다.
task1 : 누군가가 선점하고 있다.
task1 : 누군가가 선점하고 있다.
task1 : 내가 선점하고 있다.
java.lang.InterruptedException: task2 : 인터럽트 당함
task1 : 내가 선점하고 있다.
task1 : 내가 선점하고 있다.
task1 : 내가 선점하고 있다.
task1 : 내가 선점하고 있다.
task1 : 내가 선점하고 있다.

ps.
초기에는 단순히 여기 저기에 돌아다니는 예제를 참고로 작업을 하다보니 Lock 을 설정만 하고 해제를 제대로 못한 코드가 나온적이 있었다. 예를 들어 여러개의 스레드를 생성해서 테스트를 하다보면 lock을 선점하고 있던 스레드에 인터럽트를 보내서 스레드를 강제 종료 시켜도 다른 스레드에서 해당 lock 이 이미 선점되어 사용할 수 없다는 문제가 발생된다. lock을 설정해서 사용하는것도 중요하지만 해제를 꼭 해줘야 하는 부분이 synchronized 보다 많이 불편하다.

참고
http://blog.sdnkorea.com/blog/178?category=15
java concurrency in practice

Posted by 짱가쟁이
LOCKS(락)
java concurrency in practice 를 읽다보면 락 클래스가 어디에 사용되는지 자세히 설명해 놓았다. 본문을 참고로 왜 명시적인 락 클래스를 따로 만들었는지 요약해보겠다.
암묵적인 락 기능이 있는데 왜 명시적인 락 클래스를 따로 만들었을까? 암묵적인 락(synchronized)로 수용할 수 없는 문제(기능적으로 제한되는 경우)가 발생된다.

ex> 락을 확보하고자 대기하고 있는 쓰레드에 인터럽트를 걸거나, 대기 상태에 들어가지 않으면서 락을 확보하는 방법

성능
- 자바 5.0 에서는 ReentrantLock 은 암묵적인 락에 비해 훨씬 낳은 경쟁 성능(contended performance)을 보여준다.

자바 6 의 암묵적인 락은 개선되어 좀더 낳은 성능을 보임

- 블록 동기화 기능으로 synchronized 보다 진보된 능력을 제공한다. 락 타임아웃, 락당 복수의 조건 변수, 읽기/쓰기 락, 락 대기중인 스레드의 인터럽트 지원

- 전형적인 락 사용 패턴
 락 획득 -> 보호된 리소스에 엑세스 -> 락 해제
Lock lock = new ReentrantLock();
// 락 획득
lock.lock();
try {
 // critical section
} finally {
 // 획 해제
 lock.unlock();
}

- lockInterruptibly()
대기중인 스레드에 인터럽트할 수 있게 해준다. interrupt() 가 호출되면 대기 상태가 입터럽트되며 InterruptedException 이 던져진다.

락 획득이 실패할 경우에 unlock() 이 호출되면 안되기 때문에 try-finally, try-catch 로 나눠서 예외를 처리.
Lock lock = new ReentrantLock(); 

// 락을 인터럽트 시킬수 있다.
lock.lockInterruptibly();

try {
    // critical section
} finally {
    // 획 해제
    lock.unlock();
}

- tryLock()
 lock.tryLock()
  : 락이 가용 상태가 아닐 경우 즉시 실패 처림 됨.

 lock.tryLock(second, TimeUnit.SECOND)
  : 3초 동안 락 획득을 시도하고 락을 얻을 수 없으면 false를 반환하여 락을 얻을 수 없음을 알린다.
Lock lock = new ReentrantLock(); 

if(lock.tryLock()) return;

try {
    // critical section
} finally {
    // 획 해제
    lock.unlock();
}

- java.util.concurrent.locks 의 Lock 인터페이스
 1. ReentrantLock
  : 일반적으로 사용되는 락 (synchronized 랑 비슷한 유형일듯)
 
 2. ReentrantReadWriteLock 의 ReadLock , WriteLock
  : 읽고/쓰기 의 사용 비율에 따라 골라서 사용함
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
Lock readLock  = readWriteLock.readLock();
Lock writeLock = readWriteLock.writeLock();

ReentractLock 과 동일하게 사용.


Posted by 짱가쟁이