BlogJava-ゞ沉默是金ゞ-随笔分类-Java SE

jvm学习笔记

ゞ沉默是金ゞ — Fri, 14 Dec 2012 07:32:00 GMT

http://dl.iteye.com/upload/attachment/0077/7621/4698d147-570f-3fb8-a424-7e538cb587e4.bmp

ゞ沉默是金ゞ 2012-12-14 15:32 发表评论

ThreadPoolExecutor usage summary

ゞ沉默是金ゞ — Tue, 27 Nov 2012 05:43:00 GMT

摘要: 1. use ThreadPoolExecutor to do some data work, the thread number is solid. for example:storing data into cache, process large mount of data. Code highlighting produced by Actipro CodeHighlighter (fr... 阅读全文

ゞ沉默是金ゞ 2012-11-27 13:43 发表评论

Part 13: java.util.concurrent - Atomic Variables

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:50:00 GMT

In this article we will look into Atomic Variables which can help us to write lock free and wait free algorithms which were not possible prior to Java 5.0.

Two main points about Atomic Variables are

1. Help to write lock free and wait free algorithm –

Under high contention ( lots of thread are fighting for lock ), JVM spends more time with scheduling of threads, managing contention, queues of waiting threads and less time in doing the real work.

This dramatically reduces the throughput of the process.

Problem with locking:

1) Thread in block state cannot do anything else.

2) If the blocked thread is high priority, then its a big disaster.

3) Can cause Dead lock

4) Managing a Block thread is a heavy weight process, so throughput decreases.

Soon we will see how can we write lock free algorithms using atomic variables

2. Implement very light weight process like CAS –

CAS (compares and swap):

Let’s take an example to understand the concept of CAS. Suppose we have once variable “i” and we are doing some calculation over “I” and storing the result back into “i”. In a nutshell-

i = someComplicateComputation( i )

for “i” = 1,

someComplicatedComputation(i) è 1234

In CAS Process following happens-

A memory location V will be defined.

A local variable A will be defined.

A local variable B will be defined.

V will hold the initial value of “i”. So

V = i =1

A = V = 1

B = result of that computation = 1234

compare ( V , A )

both values are same --> replace V with B's value.

else

this means in the mean while someone has changed the value of V, so repeat the whole process again. Lets someone changes the value of “i”, hence V to 2.

V = 2;

A = V = 2

B = result = 3246;

compare ( V , A )

and so on...!!

This is very light weight process. This CAS technique is implemented by atomic package classes.

Example – Lets write a simple program which first increase the number by 1, then decrease the number by 1, and then increase again by 1. So overall effect is increase the number by 1. Lets run 4 threads concurrently access the method and compare the performance of AtomicInteger Vs Integer.

package com.jovialjava.blog.threads;

import java.util.concurrent.atomic.*;

public class AtomicVariableExample implements Runnable {
    AtomicInteger atomic_int_1 = new AtomicInteger();
    AtomicInteger atomic_int_2 = new AtomicInteger();
    int int_1;
    int int_2;
    private static int count = 0;

    public static void main(String[] args) {
        AtomicVariableExample pr = new AtomicVariableExample();
        new Thread(pr).start();// 1 0 1
        new Thread(pr).start();// 2 1 2
        new Thread(pr).start(); // 3 2 3
        new Thread(pr).start(); // 4 3 4
        while (true) {
            if (count == 4) {
                System.out.println(pr.atomic_int_1.get());
                System.out.println(pr.int_1);
                break;
            }
        }

    }

    public void run() {
        System.out.println("Inside run method");
        doCalc();

    }

    private void doCalc() {
        try {
            atomic_int_2 = atomic_int_1;
            int_2 = int_1;
            atomic_int_2.incrementAndGet();
            int_2 = int_2 + 1;
            Thread.sleep(1000);
            atomic_int_2.decrementAndGet();
            int_2 = int_2 - 1;
            Thread.sleep(1000);
            atomic_int_2.incrementAndGet();
            int_2 = int_2 + 1;
            Thread.sleep(1000);
            atomic_int_1 = atomic_int_2;
            int_1 = int_2;
            synchronized (this) {
                count++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

ゞ沉默是金ゞ 2012-08-06 10:50 发表评论

Part 12: java.util.concurrent : SingleThreadPool Example

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:49:00 GMT

This article will discuss about Thread pool that uses single thread to execute tasks. From Java 5.0+ one can get such pool from Executors using following method –

public static ExecutorService newSingleThreadExecutor()

Creates an Executor that uses a single worker thread operating off an unbounded queue. (Note however that if this single thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks.) Tasks are guaranteed to execute sequentially, and no more than one task will be active at any given time. Unlike the otherwise equivalent newFixedThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads.

Example-

Suppose we have 100 properties files in an application. We have one thread that can read properties file and return a map value.

Pseudo code – READER THREAD

Config Reader implements Callable

try{

// Get the file name in the constructor of thread

// Check if File exists

// Read the file and retrun the map object

}catch(Exception e){

//release all the resource

//return null

}

Main THREAD-

// Get a Single thread pool from Executors

try{

// Get the list of all properties file in the directory

// Create a READER THREAD by passing the name of file

// store the READER thread in the a list

//release all the thread in one go and get the Map objects

}catch(Exception e){

//release all the resources

// print the stack trace

}finally{

//shutdown the thread pool

}

package com.jovialjava.blog.threads;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class SingleReader implements Callable<Properties> {

    private String name = null;

    public SingleReader(String name) {
        this.name = name;
    }

    public Properties call() {
        try {
            File f = new File(name);
            Properties prop = new Properties();
            if (f.exists() && f.canRead() && f.isFile()) {
                FileInputStream in = new FileInputStream(f);
                prop.load(in);
                return prop;
            } else {
                System.err.println("Please check about this file:[" + f.getAbsolutePath() + "]");
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class SingleThreadPoolExample {
    public static String directory = "config";
    private static ExecutorService executorPool = null;

    public static void main(String args) {
        try {
            File dir = new File(directory);
            if (dir.isDirectory()) {
                List<Callable<Properties>> fileList = new ArrayList<Callable<Properties>>();
                String[] files = dir.list();
                /**
                 * Optimization - Single thread executor.
                 */
                executorPool = Executors.newSingleThreadExecutor();

                for (String file : files) {
                    Callable<Properties> reader = new SingleReader(dir.getAbsolutePath() + File.separator + file);
                    fileList.add(reader);
                }
                List<Future<Properties>> results = executorPool.invokeAll(fileList);
                /**
                 * Check how many success and how many failure
                 */
                int success = 0, failure = 0;
                for (Future<Properties> result : results) {
                    if (result.get() == null) {
                        failure++;
                    } else {
                        success++;
                    }
                }
                System.out.println("Total number of files [" + fileList.size() + "]");
                System.out.println("Success Count [" + success + "]");
                System.out.println("Failure Count [" + failure + "]");
            } else {
                throw new IllegalArgumentException("There is no such directory name -" + directory);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (executorPool != null) {
                executorPool.shutdown();
            }
        }
    }

}

ゞ沉默是金ゞ 2012-08-06 10:49 发表评论

Part 11: java.util.concurrent - CachedThreadPool Example

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:47:00 GMT

This article will discuss about Thread pool that can reuse previously constructed threads when they are available. From Java 5.0+ one can get such pool from Executors using following method –

public static ExecutorService newCachedThreadPool()

Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available. These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks. Calls to execute will reuse previously constructed threads if available. If no existing thread is available, a new thread will be created and added to the pool. Threads that have not been used for sixty seconds are terminated and removed from the cache. Thus, a pool that remains idle for long enough will not consume any resources. Note that pools with similar properties but different details (for example, timeout parameters) may be created using ThreadPoolExecutor constructors.

Example-

Suppose we have 100 properties files in an application. We have one thread that can read properties file and return a map value. We want to optimize the time to read all 100 properties file by using concurrent reading. Here optimize means – we need a perfect balance between CPU Utilization and total time consumed by reading process.

Pseudo code – READER THREAD

Config Reader implements Callable

try{

// Get the file name in the constructor of thread

// Check if File exists

// Read the file and retrun the map object

}catch(Exception e){

//release all the resource

//return null

}

Main THREAD-

// Get a Cached thread pool from Executors

try{

// Get the list of all properties file in the directory

// Create a READER THREAD by passing the name of file

// store the READER thread in the a list

//release all the thread in one go and get the Map objects

}catch(Exception e){

//release all the resources

// print the stack trace

}finally{

//shutdown the thread pool

}

package com.jovialjava.blog.threads;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class CachedReader implements Callable<Properties> {

    private String name = null;

    public CachedReader(String name) {
        this.name = name;
    }

    public Properties call() {
        try {
            File f = new File(name);
            Properties prop = new Properties();
            if (f.exists() && f.canRead() && f.isFile()) {
                FileInputStream in = new FileInputStream(f);
                prop.load(in);
                return prop;
            } else {
                System.err.println("Please check about this file:[" + f.getAbsolutePath() + "]");
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class CachedThreadPoolExample {
    public static String directory = "config";
    private static ExecutorService executorPool = null;
    private static int MAX_THREADS = 20;

    public static void main(String args) {
        try {
            File dir = new File(directory);
            if (dir.isDirectory()) {
                List<Callable<Properties>> fileList = new ArrayList<Callable<Properties>>();
                String[] files = dir.list();
                /**
                 * Optimization - Reuse the the threads.
                 */
                executorPool = Executors.newCachedThreadPool();

                for (String file : files) {
                    Callable<Properties> reader = new CachedReader(dir.getAbsolutePath() + File.separator + file);
                    fileList.add(reader);
                }
                List<Future<Properties>> results = executorPool.invokeAll(fileList);
                /**
                 * Check how many success and how many failure
                 */
                int success = 0, failure = 0;
                for (Future<Properties> result : results) {
                    if (result.get() == null) {
                        failure++;
                    } else {
                        success++;
                    }
                }
                System.out.println("Total number of files [" + fileList.size() + "]");
                System.out.println("Success Count [" + success + "]");
                System.out.println("Failure Count [" + failure + "]");
            } else {
                throw new IllegalArgumentException("There is no such directory name -" + directory);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (executorPool != null) {
                executorPool.shutdown();
            }
        }
    }
}

ゞ沉默是金ゞ 2012-08-06 10:47 发表评论

Part 10: java.util.concurrent - ScheduledThreadPool Example

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:45:00 GMT

This article will discuss about Thread pool that can schedule threads to run after a specified interval of time. From Java 5.0+ one can get such pool from Executors using following method –

public static ScheduledExecutorService

newScheduledThreadPool(int corePoolSize)

Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.

The return type of this method (return type of thread pool) is ScheduledExecutorService.Some of the salient features of ScheduledExecutorService are –

Schedule a Callable or Runnable to run once with a fixed delay after submission
Schedule a Runnable to run periodically at a fixed rate
Schedule a Runnable to run periodically with a fixed delay between executions
Submission returns a ScheduledFutureTask handle which can be used to cancel the task
.Like Timer, but supports pooling

Example:

Suppose we are building a Bank check processing system. Here is the process –
Every local branch collect cheques and create a txt file contain cheque info.
A service runs which copy the cheque txt file from local branch to main server.
A Local service runs on server which check if any file has received and notify the cheque Clearing process.

We will try to make “Local Service”, which check the file reception and “Copying process” Which copy file from client machine to Server.

Pseudo Code-

//Define Local & Copying service running interval time in Seconds

//Make an ScheduledThreadPool with pool size 2

try{

// Make Local Service thread

// Make Copying process thread

// Scheduled Both thread to run at regular interval

}catch(Exception e){

//release all resources

}

LocalService Thread-

Try{

//Check if directory exists

//Check if any file exists in directory

//return status

}catch(Exception e){

//Print necessary exception

}

Copying Process Thread-

Try{

// Check if File existin on remote server

// Copy the file to main server

}catch(Exception e){

//Print necessary exception

}

package com.jovialjava.blog.threads;

import java.io.File;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

//LOCAL SERVICE THREAD
class LocalService implements Runnable {

    private String DIRECTORY = null;

    public LocalService(String DIRECTORY) {
        this.DIRECTORY = DIRECTORY;
    }

    public void run() {
        try {
            File dir = new File(this.DIRECTORY);
            if (dir.isDirectory()) {
                if (dir.list().length > 0) {
                    System.out.println("FILE EXISTS");
                }
            } else {
                System.err.println("NO SUCH DIRECTORY [" + dir.getAbsolutePath() + "] exists");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// COPYING SERVICE THREAD
class CopyService implements Runnable {

    private String REMOTE_DIR = null;
    private String LOCAL_DIR = null;

    public CopyService(String remoteDir, String localDir) {
        this.REMOTE_DIR = remoteDir;
        this.LOCAL_DIR = localDir;
    }

    public void run() {
        try {
            File remote = new File(this.REMOTE_DIR);
            File local = new File(this.LOCAL_DIR);
            if (remote.isDirectory() && local.isDirectory()) {
                if (remote.list().length > 0) {
                    System.out.println("REMOTE FILE FOUND, COPYING");
                    // --- Call the file copying method.
                } else {
                    System.out.println("NO REMOTE FILE FOUND");
                }
            } else {
                System.err.println("PLEASE CHECK DIRECTORY [" + remote.getAbsolutePath() + " OR/AND"
                        + local.getAbsolutePath() + "] existence");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ScheduledExample {

    private static final ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
    private static final int LOCAL_INTERVAL = 5, COPY_INTERVAL = 2;
    private static final String REMOTE_DIR = "REMOTE", LOCAL_DIR = "LOCAL";

    public static void main(String args) {
        Runnable localService = new LocalService(LOCAL_DIR);
        Runnable remoteService = new CopyService(REMOTE_DIR, LOCAL_DIR);
        try {
            executor.scheduleWithFixedDelay(localService, 0, LOCAL_INTERVAL, TimeUnit.SECONDS);
            executor.scheduleWithFixedDelay(remoteService, 0, COPY_INTERVAL, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ゞ沉默是金ゞ 2012-08-06 10:45 发表评论

Part 9: java.util.concurrent : FixedThreadPool Example

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:43:00 GMT

This article will discuss about Thread pool with fixed number of thread. From Java 5.0+ one can get such pool from Executors using following method –

public static ExecutorService

newFixedThreadPool(int nThreads)

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue. At any point, at most nThreads threads will be active processing tasks. If additional tasks are submitted when all threads are active, they will wait in the queue until a thread is available. If any thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks. The threads in the pool will exist until it is explicitly shutdown.

Example-

Suppose we have 100 properties files in an application. We have one thread that can read properties file and return a map value. We want to optimize the time to read all 10 properties file by using concurrent reading. Here optimize means – we need a perfect balance between CPU Utilization and total time consumed by reading process.

Pseudo code – READER THREAD

Config Reader implements Callable

try{

// Get the file name in the constructor of thread

// Check if File exists

// Read the file and retrun the map object

}catch(Exception e){

//release all the resource

//return null

}

Main THREAD-

// Get a fixed thread pool from Executors

try{

// Get the list of all properties file in the directory

// Create a READER THREAD by passing the name of file

// store the READER thread in the a list

//release all the thread in one go and get the Map objects

}catch(Exception e){

//release all the resources

// print the stack trace

}finally{

//shutdown the thread pool

}

package com.jovialjava.blog.threads;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class Reader implements Callable<Properties> {

    private String name = null;

    public Reader(String name) {
        this.name = name;
    }

    public Properties call() {
        try {
            File f = new File(name);
            Properties prop = new Properties();
            if (f.exists() && f.canRead() && f.isFile()) {
                FileInputStream in = new FileInputStream(f);
                prop.load(in);
                return prop;
            } else {
                System.err.println("Please check about this file:[" + f.getAbsolutePath() + "]");
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class FixedThreadPoolExample {
    public static String directory = "config";
    private static ExecutorService executorPool = null;

    public static void main(String args) {
        try {
            File dir = new File(directory);
            if (dir.isDirectory()) {
                List<Callable<Properties>> fileList = new ArrayList<Callable<Properties>>();
                String[] files = dir.list();
                /**
                 * Optimization - just 20% of number of files.
                 */
                executorPool = Executors.newFixedThreadPool(files.length / 5);

                for (String file : files) {
                    Callable<Properties> reader = new Reader(dir.getAbsolutePath() + File.separator + file);
                    fileList.add(reader);
                }
                List<Future<Properties>> results = executorPool.invokeAll(fileList);
                /**
                 * Check how many success and how many failure
                 */
                int success = 0, failure = 0;
                for (Future<Properties> result : results) {
                    if (result.get() == null) {
                        failure++;
                    } else {
                        success++;
                    }
                }
                System.out.println("Total number of files [" + fileList.size() + "]");
                System.out.println("Success Count [" + success + "]");
                System.out.println("Failure Count [" + failure + "]");
            } else {
                throw new IllegalArgumentException("There is no such directory name -" + directory);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (executorPool != null) {
                executorPool.shutdown();
            }
        }
    }
}

ゞ沉默是金ゞ 2012-08-06 10:43 发表评论

Part 8: java.util.concurrent - "Executors" Factory Threads Pool

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:41:00 GMT

Today in this article we will see some of threads pool available in “Executors” Factory -

public static ExecutorService

newFixedThreadPool(int nThreads)

public static ScheduledExecutorService

newScheduledThreadPool(int corePoolSize)

Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.

public static ExecutorService newCachedThreadPool()

public static ExecutorService newSingleThreadExecutor()

ゞ沉默是金ゞ 2012-08-06 10:41 发表评论

Part 7: java.util.concurrent - invokeAll via ExecutorService

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:40:00 GMT

Submit Collection of Threads via ExecutorService

Today in next part of the series we will talk about How we can release multiple threads via Executor Interface.

As per JAVA 6.0 docs –

List<Future> invokeAll(CollectionCallable> tasks) throws InterruptedException

In traditional Java – If we have to release multiple threads- we have to create Thread objects and call

Start method one by one.

In Java 5.0 and above – If we can put all callable objects in a collection object and pass the collection objects to ExecutorService to release.

For example – If we have 1000 thread object to be released, we can create an array list and an ExecutorService object with thread pool size of 20.

// create an ExecutorService object with thread pool size = 20

// create an array List with 1000 callable objects.

// Release all threads by ExecutorService.

Some important points to note here are

Ø As ExecutorService has thread pool of 20, it will internally manage queuing and releasing of 1000 threads.
Ø invokeAll is a blocking method. It means – JVM won’t proceed to next line until all the 1000 threads are complete.
Ø All the 1000 threads must have same Return Type < T >.
Ø Future.isDone() is true for each element of the returned list
Ø A completed thread could have terminated either normally or by throwing an exception. In both the case return type of Future.isDone( ) is true.
Ø The results of this method are undefined if the given collection is modified while this operation is in progress
Ø It can throw following exceptions –
InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled.
NullPointerException - if tasks or any of its elements are null.
RejectedExecutionException - if any task cannot be scheduled for execution.

EXAMPLE –

Imagine a scenario, one needs to write create a txn file of each request coming to system. Following are the requirements-

Ø File name will be the client name.
Ø At a time, almost 1000 clients could be connected at a time, so system must be capable of creating 1000 files in one go.
Ø Process of creating one file should be less than 5 ms.
Ø Total time of creating all the files should be less than 300 ms.

Let’s write the pseudo code for this case –

File creation Thread – implements CALLABLE

// GET the File name and Raw Data in Constructor

Try{

// Create a File Object

// Create a print Writer Object

// Prepare the data and Write in the File

// Close the print Writer and File Object

// Return TRUE

} catch Exception {

return FALSE

}

Main Parent Thread

// -- In the Loop for whole Client list ---
try{

// create a file creator thread – Pass filename and raw Data

// add the thread object into an Array List

// Pass the array list to Executor Service interface and invokeAll.

// Loop in the Future and check how many threads completed successfully.

}catch Exception{

// Take necessary action

}finally{

// Shut down the ExecutorService
}

package com.jovialjava.blog.threads;

import java.io.File;
import java.io.PrintWriter;
import java.util.*;
import java.util.concurrent.*;

// FILE CREATOR THREAD
class FileTask implements Callable<Boolean> {

    private String name = null;
    private String data = null;

    public FileTask(String name, String data) {
        this.name = name;
        this.data = data;
    }

    public Boolean call() {
        try {
            File file = new File(this.name);
            PrintWriter writer = new PrintWriter(file);
            writer.write(this.data);
            writer.close();
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

// MAIN THREAD
public class InvokeAllExample {

    private static final ExecutorService executorPool = Executors.newFixedThreadPool(20);
    private static final int NO_OF_CLIENT = 1000;
    private static final String FILE_EXT = ".txt";
    private static String TXN_DATA = "SOME RANDOM TXN DATA FOR CLIENT --> ";
    private static String DIRECTORY = "EXAMPLE" + File.separator;

    static {
        if (!new File(DIRECTORY).isDirectory()) {
            new File(DIRECTORY).mkdir();
        }
    }

    public static void main(String[] args) {
        int success = 0;
        int failure = 0;
        /**
         * Lets assume we have 1000 clients connected and sending request at a
         * time.
         */
        Collection<FileTask> collection = new ArrayList<FileTask>();
        for (int i = 0; i < NO_OF_CLIENT; i++) {
            FileTask task = new FileTask(DIRECTORY + Integer.toString(i) + FILE_EXT, TXN_DATA + i);
            collection.add(task);
        }
        long startTime = new Date().getTime();
        try {
            List<Future<Boolean>> list = executorPool.invokeAll(collection);
            for (Future<Boolean> fut : list) {
                int ignore = fut.get() ? success++ : failure++;
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("TOTAL SUCCESS - " + success);
            System.out.println("TOTAL FAILURE - " + failure);
            System.out.println("Total time - " + (new Date().getTime() - startTime) + " ms");
            executorPool.shutdown();
        }
    } // End of Main

}

ゞ沉默是金ゞ 2012-08-06 10:40 发表评论

Part 6: java.util.concurrent - Lock and Condition Object

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:38:00 GMT

Today in next part of the series we will talk about How to communicate among threads using Lock and Condition Objects.

In traditional Java - If we need to communicate among threads, we syncronize code and use "wait" and "notify" methods of Object class.
From Java 5.0 and above - Lock interface provides an easier implmentation for synchronization and Condition class can be used to wait and notify threads.

Lock has several important methods such as "lock", "tryLock", "lockInterruptibly" etc, whereas Condition has "await", "signal", 'signalAll" etc. In this article we will demonstrate the usage of 3 methods - "lock" (from Lock interface), "await", "signal" (from Condition Class).

Lets try to visualize a scenario here - Assume we have 2 process "Reader" and "Writer". Writer writes on a file and Reader reads from a file. we want to add a listener to writer object so that whenever writer writes anything on a file, "Reader" will be called and it will read the same data. Before we look into codes lets look at the some important points to use Lock and Condition-

1) Lock is an Interface, the most common implementation class is ReentrantLock. Others two are - ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock
2) Condition Object is always retrieved from Lock object. For example - Condition condition = lock.newCondition( );
3) One of the best practice to use Lock is-

Lock lockObj = new ReentrantLock( );

lockObj.lock( );

try{

.... code..

}finally{

lockObj.unlock( );

}

4) condition.await, condition.signal, condition.signalAll methods should only be called once you have acquired the lock by - lockObj.lock( ).
In our example, the design of the class will be something like this -
> One lock Object == fileLock
> One condition Object = condition = fileLock.newCondition

Pseudo code for Writer Thread

// GET the LOCK
try{
  // -- In the Loop untill EXIT---
   //Write on the file
   // Signal the READER
   //If EXIT signal then exit else "WAIT for READER to SIGNAL"
}finally{
  // RELEASE the LOCK
}

pseudo code for Reader Thread

// GET the LOCK
try{
  // -- In the Loop untill EXIT---
   //Read from the file
   // Signal the WRITER
   // If EXIT signal - then exit else "WAIT for WRITER to SIGNAL"
}finally{
  // RELEASE the LOCK
}

package com.jovialjava.blog.threads;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.PrintWriter;
import java.security.SecureRandom;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {

    private static final String fileName = "LockExample.txt";
    private static final String EXIT_FLAG = "BYE";
    private static final int NO_OF_LINES = 10;
    private static final Lock fileLock = new ReentrantLock();
    private static final Condition condition = fileLock.newCondition();
    private static final ExecutorService executorPool = Executors.newFixedThreadPool(2);

    public static void main(String args) {
        Runnable fileWriter = new FileWrite();
        Runnable fileReader = new FileRead();
        executorPool.submit(fileReader);
        executorPool.submit(fileWriter);
        executorPool.shutdown();
    }

    /**
     * This thread will write on a file and inform the reader thread to read it.
     * If it has not written the EXIT flag then it will go into wait stage and
     * will wait for READER to signal that it safe to write now.
     */
    public static class FileWrite implements Runnable {

        public void run() {
            try {
                fileLock.lock();
                for (int i = 0; i < NO_OF_LINES; i++) {
                    PrintWriter writer = new PrintWriter(new File(fileName));
                    if (i != NO_OF_LINES - 1) {
                        int random = new SecureRandom().nextInt();
                        System.out.println("WRITER WRITING " + random);
                        writer.println(random);
                        writer.close();
                        // signallng to READER that its safe to read now.
                        condition.signal();
                        System.out.println("Writer waiting");
                        condition.await();
                    } else {
                        writer.println(EXIT_FLAG);
                        System.out.println("WRITER EXITING ");
                        writer.close();
                        // AS it was an exit flag so no need to wait, just
                        // signal the reader.
                        condition.signal();
                    }
                }
            } catch (Exception e) {
                System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!EXCEPTION!!!!!!!!!!!!!!!!!!!!!!!!");
                e.printStackTrace();
            } finally {
                fileLock.unlock();
                // Delete the file, require in case if one wants to run demo
                // again.
                File file = new File(fileName);
                file.delete();
                try {
                    file.createNewFile();
                } catch (Exception e) {
                }
            }
        }
    }

    /**
     * This thread will read from the file and inform the writer thread to write
     * again. If it has not read the EXIT flag then it will go into wait stage
     * and will wait for WRITER to signal that it safe to read now.
     */
    public static class FileRead implements Runnable {

        public void run() {
            String data = null;
            fileLock.lock();
            try {
                while (true) {
                    BufferedReader reader = new BufferedReader(new FileReader(fileName));
                    data = reader.readLine();
                    System.out.println("READ DATA - " + data);
                    reader.close();
                    if (data == null || !data.equals(EXIT_FLAG)) {
                        condition.signalAll();
                        System.out.println("Reader Waiting");
                        condition.await();
                    } else {
                        System.out.println("READER EXITING");
                        condition.signal();
                        break;
                    }
                }
            } catch (Exception e) {
                System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!EXCEPTION!!!!!!!!!!!!!!!!!!!!!!!!");
                e.printStackTrace();
            } finally {
                fileLock.unlock();
            }
        }
    }
}

ゞ沉默是金ゞ 2012-08-06 10:38 发表评论

Part 5: java.util.concurrent - Submit Callable< T > via ExecutorService

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:35:00 GMT

Future submit(Callable c)

Today in next part of the series we will talk about submission of callable task via executor service.

As per JAVA version 6.0, ExecutorService Interface has following method -
Future< T > submit( callable c )

Submits a Callable task for execution and returns a Future representing that task computation.
Future< T > will return T on successful completion of the process, otherwise result will not be T.

Lets start with Callable task - As we know that Callable interface has following method - public T call()
So when we say - ExecutorService.submit(Callable Task) --> It starts a new stack starting with call method of callable task, as call method can return T so does future object. Due to this reason the signature of submit(Callable c) is Future< T >.
T --> means anything that extends Object.

package com.jovialjava.blog.threads;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableExample {

    private static final ExecutorService executorPool=Executors.newFixedThreadPool(2);

    public static void main(String[] args) {
        CallableTask_1 task_1 = new CallableTask_1();
        CallableTask_2 task_2 = new CallableTask_2();

        /**
         * Submit the first task
         */
        Future<Boolean> fut_1 = executorPool.submit(task_1);
        Future<Boolean> fut_2 = executorPool.submit(task_2);

        try{
            if(fut_1.get()){
                System.out.println("TASK 1 completed SUCCESSFULLY");
            }
            if(fut_2.get()){
                System.out.println("TASK 2 completed SUCCESSFULLY");
            }
        }catch(ExecutionException e){
            System.out.println(e.getMessage());
        }catch(InterruptedException e){
            System.out.println(e.getMessage());
        }finally{
            /**====VERY IMPORTANT===
             * This is required to stop the executor pool to
             * stop accepting new request.
             */
            executorPool.shutdown();
        }

    }


    /**
     * This task will complete successfully
     */
    public static class CallableTask_1 implements Callable<Boolean>{
        public Boolean call()throws NullPointerException{
            System.out.println("Hi, Inside Callable Task 1");
            return true;
        }

    }

    /**
     * This task will result in error.
     */
    public static class CallableTask_2 implements Callable<Boolean>{
        public Boolean call()throws NullPointerException{
            System.out.println("Hi, Inside Callable Task 2");
            throw new IllegalStateException("Callable Task Exception");
        }

    }
}

ゞ沉默是金ゞ 2012-08-06 10:35 发表评论

Part 4: java.util.concurrent - Submit Runnable via ExecutorService

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:33:00 GMT

Future submit( Runnable r )

Today in part 4 of the series we will talk about submission of runnable task via executor service. This method can be very beneficial if someone wants to upgrade legacy code from 1.4 to 1.5 onwards.
As per JAVA version 6.0, ExecutorService Interface has following method -

Future< ? > submit( Runnable r )

> Submits a Runnable task for execution and returns a Future representing that task.
> This method will return NULL on successful completeion of the process, otherwise result will not be null.

Lets start with Runnable task - As we know that Runnable interface has following method - public void run()
So when we say - ExecutorService.submit(Runnable Task) --> It starts a new stack starting with run method of runnable task, but as run method can not return any value so does future object. Due to this reason the signature of submit(Runnable r) is Future< ? >.
? --> means anything that extends Object, has no lower limit

package com.jovialjava.blog.threads;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class RunnableExample {

    private static final ExecutorService executorPool=Executors.newFixedThreadPool(2);

    public static void main(String[] args) {
        RunnableTask_1 task_1 = new RunnableTask_1();
        RunnableTask_2 task_2 = new RunnableTask_2();

        /**
         * Submit the first task
         */
        Future fut_1 = executorPool.submit(task_1);
        Future fut_2 = executorPool.submit(task_2);

        try{
            if(fut_1.get() == null){
                System.out.println("TASK 1 completed SUCCESSFULLY");
            }
            if(fut_2.get() == null){
                System.out.println("TASK 2 completed SUCCESSFULLY");
            }
        }catch(ExecutionException e){
            System.out.println(e.getMessage());
        }catch(InterruptedException e){
            System.out.println(e.getMessage());
        }finally{
            /**====VERY IMPORTANT===
             * This is required to stop the executor pool to
             * stop accepting new request.
             */
            executorPool.shutdown();
        }

    }


    /**
     * This task will complete successfully
     */
    public static class RunnableTask_1 implements Runnable{
        public void run()throws NullPointerException{
            System.out.println("Hi, Inside Runnable Task 1");
        }

    }

    /**
     * This task will result in error.
     */
    public static class RunnableTask_2 implements Runnable{
        public void run()throws NullPointerException{
            System.out.println("Hi, Inside Runnable Task 2");
            throw new IllegalStateException("Runnable Task Exception");
        }

    }
}

ゞ沉默是金ゞ 2012-08-06 10:33 发表评论

Part 3:java.util.concurrent- ExecutorService Interface

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:30:00 GMT

xecutorService interface provide us a base to release threads. It maintains everything related to threads.
Analogy:
This is very much similar to a small IT organization where a project manager handles all activities related to developers. Activities such as -how many person will be there in each team, if one team has less work then releasing some person from that team and shifting to another team, generate weekly report to submit to company etc.
If we see deeply -functions of ExecutorService are nothing but an exact replica of what a project manager does in a company.
We create thread task , ExecutorService helps to release a thread and give the result back to us similarly company hires a person and project manager takes out the work from that person and company gets benefited.
Threads Pool in ExecutorService Implementation:
Most of the executor implementations in java.util.concurrent use thread pools, which consist of worker threads. This kind of thread exists separately from the Runnable and Callable tasks it executes and is often used to execute multiple tasks.
Using worker threads minimizes the overhead due to thread creation. Thread objects use a significant amount of memory, and in a large-scale application, allocating and deallocating many thread objects creates a significant memory management overhead.
Analogy:
This is very much similar to big organizations in which a project manager have project leaders working under him to take care of developers. so project leaders are nothing but acting as thread POOL.
Fixed Thread POOL:
One common type of thread pool is the fixed thread pool. This type of pool always has a specified number of threads running; if a thread is somehow terminated while it is still in use, it is automatically replaced with a new thread. Tasks are submitted to the pool via an internal queue, which holds extra tasks whenever there are more active tasks than threads.
Advantage:
An important advantage of the fixed thread pool is that applications using it degrade gracefully. To understand this, consider a web server application where each HTTP request is handled by a separate thread. If the application simply creates a new thread for every new HTTP request, and the system receives more requests than it can handle immediately, the application will suddenly stop responding to all requests when the overhead of all those threads exceed the capacity of the system. With a limit on the number of the threads that can be created, the application will not be servicing HTTP requests as quickly as they come in, but it will be servicing them as quickly as the system can sustain.
Example-
Suppose there are 8 threads in the Thread Pool.
First request comes in the queue : check if there is any Thread in the pool --> Yes , execute the task.
9th request comes in : No thread in pool currently --> Hold the task in the queue( Degrading the performance) --> wait until one among the currently running 8 task finishes --> as soon as one finished, run the ninth task ( graceful work)

ExecutorServiceInterface -Important Methods

Provide submit(…) in spite of execute(…)
submit( Runnable r) --> return Future< ? >
submit( Callable c) --> return Future
invokeAll( Collection< ? extends Callable> task ) --> List>
shutdownNow( ) --> List

ゞ沉默是金ゞ 2012-08-06 10:30 发表评论

Part 2: java.util.concurrent - Future

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:28:00 GMT

Future:
A Future represents the result of an asynchronous computation. Future has been provide with some really powerful methods. For Instance -
1) We can check whether a task has been completed or not.
2) We can cancel a task.
3) Check whether task was cancelled or complete normally.

Methods-

boolean cancel(boolean mayInterruptIfRunning) -
This method does following -
1) If the process(Thread) has not started, then cancel the thread.
2) If the process has started, then check if
mayInterruptIfRunning = true ==> Inturrept the thread and cancel it
mayInterruptIfRunning = false ==> Let it run
This attempt will fail if the task has already completed, has already been cancelled, or could not be cancelled for some other reason.
After this method returns, subsequent calls to isDone() will always return true.
Subsequent calls to isCancelled() will always return true if this method returned true.

boolean isCancelled()
Returns true if this task was cancelled before it completed normally

V get() throws InterruptedException, ExecutionException
This method is a blocking call. It will cause JVM to wait if necessary for the computation to complete, and then retrieves its result.

boolean isDone()
Returns true if this task completed. Completion may be due to normal termination, an exception, or cancellation - in all of these cases, this method will return true.

package com.jovialjava.blog.threads;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureExample {
    /**
     * Executor pool is a new concept in JAVA 5+, it can help to release
     * a thread. It maintains a pool of threads, It reuses them, also align them in
     * a queue. Here we are creating pool of 1 thread.
     */
    private static final ExecutorService executorPool=Executors.newFixedThreadPool(5);

    public static void main(String args){
        CallableTask call = new CallableTask();
        try{
            /**
             * Future is result of asynchronous computation.
             * It may possible that CallableTask has not started yet
             * but 'ExecutorService' gives the result via Future
             * Object.
             */
            Future<String> future = executorPool.submit(call);
            /**
             * We can check if CallableTask has been completed.
             */
            System.out.println("Status of Callable Task [Is Completed ? "+ future.isDone()+ "]");
            /**
             * We can get the result of callable Task.
             * Note : future.get() is a blocking call, It will wait until the associated process finishes.
             */
            System.out.println("Result of callable task ["+ future.get()+"]");
            /**
             * We can cancel the task.
             */
            System.out.println("Trying to cancel the task [Is Cancelled ? "+ future.cancel(false)+ "]");
            /**
             * We can see if the task was canceled.
             * Returns true if this task was canceled before it completed normally
             */
            System.out.println("Was task canceled before normal complition ? -"+ future.isCancelled());


        }catch(Exception e){
            e.printStackTrace();
        }finally{
            executorPool.shutdownNow();
        }

    }


    /*
     *Callable is defined as Callable
     *
     */
    public static class CallableTask implements Callable<String>{

        public String call( ){
            System.out.println("Inside CALLABLE TASK");
            return "~~JOVIAL JAVA~~";
        }
    }
}

ゞ沉默是金ゞ 2012-08-06 10:28 发表评论

Part 1: java.util.concurrent - Runnable Vs Callable in Java

ゞ沉默是金ゞ — Mon, 06 Aug 2012 02:24:00 GMT

About Runnable:

Runnable interface is implemented by the Thread class as well and it's a common protocol for all the objects who wish to execute in a different thread. It's one of the ways of creating threads in Java. The other way to create a thread is by subclassing the Thread class. A class implementing Runnable interface can simply pass itself to create a Thread instance and can run thereafter. This eliminates the need of subclassing the Thread class for the purpose of executing the code in a separate thread.

As long as we don't wish to override other methods of the Thread class, it may be a better idea to implement the Runnable interface to enable multithreading capabilities to a class than enabling the same by extending the Thread class.

About Callable:

The designers of Java felt a need of extending the capabilities of the Runnable interface, but they didn't want to affect the uses of the Runnable interface and probably that was the reason why they went for having a separate interface named Callable in Java 1.5 than changing the already existing Runnable interface which has been a part of Java since Java 1.0.

Similarities:

1) Both threads can be used to cause a separate stack for a thread.

2) Both has only one method : Inside Runnable it is called as

public abstract void run( );

Inside callable the method is being called as

public abstract call() ;
(Note : V can be any valid object in JAVA)

Differences:

1) Return Type -
public abstract void run() --> Return type "void"
public abstract call() --> Return type "Any valid JAVA Object"

2) Run method can not throw any checked Exception, whereas
public abstract call() throw checkedException
Call method can throw any checked Exception.

package com.jovialjava.blog.threads;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
* This program has been written to demonstrate the usage
* of Runnable and Callable Interfaces. Jovial Java makes
* no guarantee of any harm or any problem caused by using this
* program.
*/
public class Run_Vs_Call {


    public static void main(Stringargs){
        CallableTask call = new CallableTask();
        RunnableTask run = new RunnableTask();
        try{
            /*
             * We need a Future task Launcher to launch Callable Class
             */
            FutureTask<String> callTask = new FutureTask<String>(call);
            /*
             * We need a Thread Launcher to to launch Runnable Class
             */
            Thread runTask = new Thread(run);
            callTask.run();
            runTask.start();

            /*
             * Get is a blocking call, JVM will wait here until Call task
             * finishes execution.
             */
            System.out.println(callTask.get());


        }catch(Exception e){
            e.printStackTrace();
        }

    }

    /*
     *Callable is defined as Callable
     *
     */
    public static class CallableTask implements Callable<String>{

        public String call( ){
            System.out.println("Inside call method..!!");
            return "hello";
        }
    }
    /*
     * Runnable Interface Implementation
     */
    public static class RunnableTask implements Runnable{
        public void run(){
            System.out.println("Inside Run Method, I can not return any thing");
        }
    }

}

ゞ沉默是金ゞ 2012-08-06 10:24 发表评论

文件追加内容实例

ゞ沉默是金ゞ — Tue, 03 Jul 2012 11:10:00 GMT

文件追加内容实例

package org.duke.java.util;

import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;

public class AppendToFile {
    /**
     * A方法追加文件：使用RandomAccessFile
     */
    public static void appendMethodA(String fileName, String content) {
        try {
            // 打开一个随机访问文件流，按读写方式
            RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
            // 文件长度，字节数
            long fileLength = randomFile.length();
            //将写文件指针移到文件尾。
            randomFile.seek(fileLength);
            randomFile.writeBytes(content);
            randomFile.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * B方法追加文件：使用FileWriter
     */
    public static void appendMethodB(String fileName, String content) {
        try {
            //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
            FileWriter writer = new FileWriter(fileName, true);
            writer.write(content);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        String fileName = "C:/Shawn/test.txt";
        String content = "new append!";
        //按方法A追加文件
        AppendToFile.appendMethodA(fileName, content);
        AppendToFile.appendMethodA(fileName, "append end. \n");
        //显示文件内容
        ReadFromFile.readFileByLines(fileName);
        //按方法B追加文件
        AppendToFile.appendMethodB(fileName, content);
        AppendToFile.appendMethodB(fileName, "append end. \n");
        //显示文件内容
        ReadFromFile.readFileByLines(fileName);
    }
}

ゞ沉默是金ゞ 2012-07-03 19:10 发表评论

文件读取实例

ゞ沉默是金ゞ — Tue, 03 Jul 2012 11:07:00 GMT

摘要: 读取文件实例 Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->package org.duke.java.util;import java.io.BufferedReader;import java.io.File;i... 阅读全文

ゞ沉默是金ゞ 2012-07-03 19:07 发表评论

How to Create Client/Server Keystores using Java Keytool

ゞ沉默是金ゞ — Tue, 26 Jun 2012 11:15:00 GMT

Here I have described how to create client/server keystores which can be used to secure Axsi2 webservices and invoke Axis2 secured webservices. i.e. It can be easily used with any WSO2 Product to experience security scenarios.More detailed explanation on creating client/server keystores using openssl including Certificate Authority(CA) Requests, can be found at http://wso2.org/library/174.

Java keytool stores the keys and certificates in a keystore, protected by a keystore password. Further, it protects private key again with another password. A Java keystore contains private-public key pair and multiple trusted certificate entries. All entries in a keystore are referred by aliases. Both private key and self signed public key is referred by one alias while any other trusted certificates are referred by different individual aliases.

As the first step, let's create a keystore for server. In order to do it, execute following command in a terminal. "server" in the following command corresponds to the private key/self signed public key certificate alias in the keystore while "server.jks" is the name of the creating keystore file.

keytool -genkey -alias server -keyalg RSA -keystore server.jks

when you execute the above command it will first prompt you to specify a password which is corresponded to the keystore password. Then it will prompt several questions. You can give answers that you wish. At the end it will ask for a password again, which will be used to secure the generated private key.

Enter keystore password:
Re-enter new password:
What is your first and last name?
[Unknown]: Ruchira Wageesha
What is the name of your organizational unit?
[Unknown]: Mashup Server
What is the name of your organization?
[Unknown]: WSO2
What is the name of your City or Locality?
[Unknown]: Ahangama
What is the name of your State or Province?
[Unknown]: Southern
What is the two-letter country code for this unit?
[Unknown]: LK
Is CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK correct?
[no]: yes
Enter key password for
(RETURN if same as keystore password):

Once you successfully completed this, java keytool will create a file named "server.jks". In the same way, you can create a client keystore named "client.jks" with the alias "client" using following command.

keytool -genkey -alias client -keyalg RSA -keystore client.jks

Now, you have two files named client.jks and server.jks. You can view the content of these keystore files using the following command. Replacess "ruchira" with the keystore password you entered while creating the keystore.

keytool -list -v -keystore server.jks -storepass ruchira

This will list something like this.

Keystore type: JKS
Keystore provider: SUN

Your keystore contains 1 entry

Alias name: server
Creation date: Jul 8, 2010
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Issuer: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Serial number: 4c356225
Valid from: Thu Jul 08 10:59:09 IST 2010 until: Wed Oct 06 10:59:09 IST 2010
Certificate fingerprints:
MD5: 60:0B:48:0D:DB:56:8C:68:8C:2D:94:4A:D6:DA:04:B8
SHA1: A7:CE:57:10:70:87:C1:2C:C0:9D:1D:90:8C:BB:69:B6:66:26:97:13
Signature algorithm name: SHA1withRSA
Version: 3

*******************************************
*******************************************

The next step is, getting server's self signed public key certificate and storing it in client's keystore. And getting and storing client's self signed public key certificate in server's keystore. In order to do that, first we need to export both server and client public key certificates into files. Using the following command, you can export server's public key certificate into server.cert file and client's public key certificate into client.cert file.

keytool -export -file server.cert -keystore server.jks -storepass ruchira -alias server
keytool -export -file client.cert -keystore client.jks -storepass ruchira -alias client

Now you have server.cert and client.cert. You can use following commands to view certificate contents.

keytool -printcert -v -file server.cert
keytool -printcert -v -file client.cert

As the last step, we need to import server.cert into client keystore and client.cert into server keystore. As I mentioned earlier, each entry of a Java Keystore is stored against an alias. So, we need to specify aliases here, which will be used to refer the certificates that we are going to store.

keytool -import -file client.cert -keystore server.jks -storepass ruchira -alias client

Above command will store client's self signed public key certificate(client.cert) in server.jks against the alias "client". So, using "client" alias on server.jks, we can refer client's certificate anytime. Likewise, following command will store server.cert within client.jks against the alias "server".

keytool -import -file server.cert -keystore client.jks -storepass ruchira -alias server

After all, please view the content of both keystore again using following commands.

keytool -list -v -keystore server.jks -storepass ruchira
keytool -list -v -keystore client.jks -storepass ruchira

It will give you something like bellow for server.jks

Keystore type: JKS
Keystore provider: SUN

Your keystore contains 2 entries

Alias name: server
Creation date: Jul 8, 2010
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Issuer: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Serial number: 4c3562a0
Valid from: Thu Jul 08 11:01:12 IST 2010 until: Wed Oct 06 11:01:12 IST 2010
Certificate fingerprints:
MD5: AB:77:72:F1:0D:09:55:E3:B6:D3:DC:A6:4D:D4:39:36
SHA1: D7:C1:60:5C:7E:34:40:A9:0B:E4:2C:65:6C:E0:79:7C:EE:37:A7:19
Signature algorithm name: SHA1withRSA
Version: 3

*******************************************
*******************************************

Alias name: client
Creation date: Jul 8, 2010
Entry type: trustedCertEntry

Owner: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Issuer: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Serial number: 4c356225
Valid from: Thu Jul 08 10:59:09 IST 2010 until: Wed Oct 06 10:59:09 IST 2010
Certificate fingerprints:
MD5: 60:0B:48:0D:DB:56:8C:68:8C:2D:94:4A:D6:DA:04:B8
SHA1: A7:CE:57:10:70:87:C1:2C:C0:9D:1D:90:8C:BB:69:B6:66:26:97:13
Signature algorithm name: SHA1withRSA
Version: 3

*******************************************
*******************************************

something like below for client.jks

Keystore type: JKS
Keystore provider: SUN

Your keystore contains 2 entries

Alias name: server
Creation date: Jul 8, 2010
Entry type: trustedCertEntry

Owner: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Issuer: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Serial number: 4c3562a0
Valid from: Thu Jul 08 11:01:12 IST 2010 until: Wed Oct 06 11:01:12 IST 2010
Certificate fingerprints:
MD5: AB:77:72:F1:0D:09:55:E3:B6:D3:DC:A6:4D:D4:39:36
SHA1: D7:C1:60:5C:7E:34:40:A9:0B:E4:2C:65:6C:E0:79:7C:EE:37:A7:19
Signature algorithm name: SHA1withRSA
Version: 3

*******************************************
*******************************************

Alias name: client
Creation date: Jul 8, 2010
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Issuer: CN=Ruchira Wageesha, OU=Mashup Server, O=WSO2, L=Ahangama, ST=Southern, C=LK
Serial number: 4c356225
Valid from: Thu Jul 08 10:59:09 IST 2010 until: Wed Oct 06 10:59:09 IST 2010
Certificate fingerprints:
MD5: 60:0B:48:0D:DB:56:8C:68:8C:2D:94:4A:D6:DA:04:B8
SHA1: A7:CE:57:10:70:87:C1:2C:C0:9D:1D:90:8C:BB:69:B6:66:26:97:13
Signature algorithm name: SHA1withRSA
Version: 3

*******************************************
*******************************************

If everything went well, you might have successfully created server.jks and client.jks which can be used to secure Axis2 Services and access those secured services.

ゞ沉默是金ゞ 2012-06-26 19:15 发表评论

Using Java Reflection

ゞ沉默是金ゞ — Tue, 26 Jun 2012 11:04:00 GMT

摘要: Reflection is a feature in the Java programming language. It allows an executing Java program to examine or "introspect" upon itself, and manipulate internal properties of the program. For example, it... 阅读全文

ゞ沉默是金ゞ 2012-06-26 19:04 发表评论

tomcat 配置用户

ゞ沉默是金ゞ — Mon, 09 Nov 2009 08:32:00 GMT

ゞ沉默是金ゞ 2009-11-09 16:32 发表评论

Eclipse中10个比较有用的快捷键组合(转)

ゞ沉默是金ゞ — Tue, 02 Jun 2009 06:55:00 GMT

一个Eclipse骨灰级开发者总结了他认为最有用但又不太为人所知的快捷键组合。通过这些组合可以更加容易的浏览源代码，使得整体的开发效率和质量得到提升。

1. ctrl+shift+r：打开资源

这可能是所有快捷键组合中最省时间的了。这组快捷键可以让你打开你的工作区中任何一个文件，而你只需要按下文件名或mask名中的前几个字母，比如applic*.xml。美中不足的是这组快捷键并非在所有视图下都能用。

2. ctrl+o：快速outline

如果想要查看当前类的方法或某个特定方法，但又不想把代码拉上拉下，也不想使用查找功能的话，就用ctrl+o吧。它可以列出当前类中的所有方法及属性，你只需输入你想要查询的方法名，点击enter就能够直接跳转至你想去的位置。

3. ctrl+e：快速转换编辑器

这组快捷键将帮助你在打开的编辑器之间浏览。使用ctrl+page down或ctrl+page up可以浏览前后的选项卡，但是在很多文件打开的状态下，ctrl+e会更加有效率。

4. ctrl+2，L：为本地变量赋值

开发过程中，我常常先编写方法，如Calendar.getInstance()，然后通过ctrl+2快捷键将方法的计算结果赋值于一个本地变量之上。这样我节省了输入类名，变量名以及导入声明的时间。Ctrl+F的效果类似，不过效果是把方法的计算结果赋值于类中的域。

5. alt+shift+r：重命名

重命名属性及方法在几年前还是个很麻烦的事，需要大量使用搜索及替换，以至于代码变得零零散散的。今天的Java IDE提供源码处理功能，Eclipse也是一样。现在，变量和方法的重命名变得十分简单，你会习惯于在每次出现更好替代名称的时候都做一次重命名。要使用这个功能，将鼠标移动至属性名或方法名上，按下alt+shift+r，输入新名称并点击回车。就此完成。如果你重命名的是类中的一个属性，你可以点击alt+shift+r两次，这会呼叫出源码处理对话框，可以实现get及set方法的自动重命名。

6. alt+shift+l以及alt+shift+m：提取本地变量及方法

源码处理还包括从大块的代码中提取变量和方法的功能。比如，要从一个string创建一个常量，那么就选定文本并按下alt+shift+l即可。如果同一个string在同一类中的别处出现，它会被自动替换。方法提取也是个非常方便的功能。将大方法分解成较小的、充分定义的方法会极大的减少复杂度，并提升代码的可测试性。

7. shift+enter及ctrl+shift+enter

Shift+enter在当前行之下创建一个空白行，与光标是否在行末无关。Ctrl+shift+enter则在当前行之前插入空白行。

8. Alt+方向键

这也是个节省时间的法宝。这个组合将当前行的内容往上或下移动。在try/catch部分，这个快捷方式尤其好使。

9. ctrl+m

大显示屏幕能够提高工作效率是大家都知道的。Ctrl+m是编辑器窗口最大化的快捷键。

10. ctrl+.及ctrl+1：下一个错误及快速修改

ctrl+.将光标移动至当前文件中的下一个报错处或警告处。这组快捷键我一般与ctrl+1一并使用，即修改建议的快捷键。新版Eclipse的修改建议做的很不错，可以帮你解决很多问题，如方法中的缺失参数，throw/catch exception，未执行的方法等等。

更多快捷键组合可在Eclipse按下ctrl+shift+L查看。

转自：http://www.blogjava.net/Werther/archive/2009/06/02/279574.html

ゞ沉默是金ゞ 2009-06-02 14:55 发表评论

用 * 打印出各种图形

ゞ沉默是金ゞ — Tue, 02 Jun 2009 06:43:00 GMT

摘要: 先看效果：代码： public class PrintTriangle { public static void main(String[] args) { &n... 阅读全文

ゞ沉默是金ゞ 2009-06-02 14:43 发表评论

jconsole

ゞ沉默是金ゞ — Wed, 06 May 2009 06:47:00 GMT

jconsole 可以很方便的监控本机的所有 Java 应用和远程的应用.

监控本地应用

首先就是启动您要监控的应用, 例如我用 JDK 1.6 来启动了 Tomcat, 或者 Eclipse 也可以, 可以在任务管理器(Ctrl+Alt+Del可以调出来, 或者在任务栏点击右键)里看到进程ID, 例如我这里是 6132.

接着在 JDK 安装目录中(/bin/jconsole.exe)启动 jconsole.exe (双击或者在 cmd 里面敲入 jconsole), 主界面会提示您建立一个新连接:

可以看到进程ID, 选择它, 然后点击"连接". 这些 ID 必须都是用 JDK 1.6 的 java.exe 启动的, 否则在列表里看不到.

JConsle 能监控内存,线程,类的数目和CPU然后点击各个 Tab 可以看到详细的输出, 详细的输出包括:
内存: 堆/非堆, 峰值, 内存的各个部分, 例如 Perm, Eden 等的大小曲线图.
线程: 峰值, 所有线程的列表, 堆栈跟踪(哪个对象中的线程)等. 还可以强制执行GC.
类: 峰值, 类总数曲线图.
MBean: 一些 JVM 参数的详细 MBean 信息.

监控远程进程

首先需要在运行的应用上启用远程管理, 参数如下(简单期间就不加用户验证了):
java -Dcom.sun.management.jmxremote.port=1090 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -jar ../demo/jfc/Java2D/Java2Demo.jar

然后连接的时候选择远程进程, 地址输入:

localhost:1090

即可.当然在别的电脑上(一般是局域网)可以输入那个电脑的IP.

综述: 使用 JConsole 可以简单的监控 Server 状态, 但是本身要占一定的资源, 不过 JVM 自带的监控, 理论上讲应该是占资源很小很小的, 可以用它来方便的了解 Web 服务器应用进程的状态. 如果要调优应用, 还是使用 JProfiler 等工具更好一些, 当然它们占的资源也更大.

ゞ沉默是金ゞ 2009-05-06 14:47 发表评论

再谈类的初始化

ゞ沉默是金ゞ — Tue, 31 Mar 2009 07:17:00 GMT

摘要: 类的初始化和对象初始化是 JVM 管理的类型生命周期中非常重要的两个环节，Google 了一遍网络，有关类装载机制的文章倒是不少，然而类初始化和对象初始化的文章并不多，特别是从字节码和 JVM 层次来分析的文章更是鲜有所见。本文主要对类和对象初始化全过程进行分析，通过一个实际问题引入，将源代码转换成 JVM 字节码后，对 JVM 执行过程的关键点进行全面解析，并在文中穿插入了相关 JVM 规范... 阅读全文

ゞ沉默是金ゞ 2009-03-31 15:17 发表评论

类的初始化顺序

ゞ沉默是金ゞ — Mon, 30 Mar 2009 01:59:00 GMT

class ClassA{
    static{
        System.out.println("ClassA's static.");
    }
    public ClassA(){
        System.out.println("ClassA's constructor.");
    }
}
class ClassB extends ClassA{
    static{
        System.out.println("ClassB's static.");
    }
    public ClassB(){
        System.out.println("ClassB's constructor.");
    }
}
public class TestClass {

    public static void main(String[] args) {
        ClassA a = new ClassB();
        System.out.println("===============");
        a = new ClassB();
    }

}

输出：

ClassA's static.
ClassB's static.
ClassA's constructor.
ClassB's constructor.
===============
ClassA's constructor.
ClassB's constructor.

我个人分析如下：
当执行到ClassA a = new ClassB();时开始加载ClassB，这里因为ClassB继承ClassA，所以加载ClassA，在加载ClassA的时候执行输出：ClassA's static.。
ClassA加载完后，加载ClassB，这时执行结果为：ClassB's static.。两个类都加载完后开始构建对象。
在构建ClassB对象时，得先构建父类对象ClassA，所以执行分别为：ClassA's constructor.
ClassB's constructor.那么这句话完了。

到a=new ClassB();时，由于ClassA，ClassB已经被加载过，在内存中。所以只是简单的进行构建对象。输出：ClassA's constructor.
ClassB's constructor.
希望大家多多指教。(来源于网络)

ゞ沉默是金ゞ 2009-03-30 09:59 发表评论

优秀程序员的十个习惯(摘)

ゞ沉默是金ゞ — Mon, 23 Mar 2009 01:59:00 GMT

在这个世界上，有数百万的人热衷于软件开发，他们有很多名字，如：软件工程师（Software Engineer），程序员（Programmer），编码人（Coder），开发人员（Developer）。经过一段时间后，这些人能够成为一个优秀的编码人员，他们非常熟悉如何用计算机语言来完成自己的工作。但是，如果你要成为一个优秀的程序员，你还可以需要有几件事你需要注意，如果你能让下面十个条目成为你的习惯，那么你才能真正算得上是优秀程序员。

1. 学无止境。就算是你有了10年以上的程序员经历，你也得要使劲地学习，因为你在计算机这个充满一创造力的领域，每天都会有很多很多的新事物出现。你需要跟上时代的步伐。你需要去了解新的程序语言，以及了解正在发展中的程序语言，以及一些编程框架。还需要去阅读一些业内的新闻，并到一些热门的社区去参与在线的讨论，这样你才能明白和了解整个软件开发的趋势。在国内，一些著名的社区例如：CSDN，ITPUB，CHINAUINX等等，在国外，建议你经常上一上digg.com去看看各种BLOG的聚合。

2. 掌握多种语言。程序语言总是有其最适合的领域。当你面对需要解决的问题时，你需要找到一个最适合的语言来解决这些问题。比如，如果你需要性能，可能C/C++是首选，如果你需要跨平台，可能Java是首选，如果你要写一个Web上的开发程序，那么 PHP，ASP，Ajax，JSP可能会是你的选择，如果你要处理一些文本并和别的应用交互，可能Perl, Python会是最好的。所以，花一些时间去探索一下其它你并熟悉的程序语言，能让你的眼界变宽，因为你被武装得更好，你思考问题也就更为全面，这对于自己和项目都会有好的帮助。

3. 理性面对不同的操作系统或技术。程序员们总是有自己心目中无可比拟的技术和操作系统，有的人喜欢Ubuntu，有的人喜欢Debian，还有的人喜欢Windows，以及FreeBSD，MacOSX或Solaris等等。看看我的BLOG(http://blog.csdn.net/haoel)中的那篇《其实Unix很简单》后的回复你就知道程序员们在维护起自己的忠爱时的那份执着了。只有一部分优秀的程序员明白不同操作系统的优势和长处和短处，这样，在系统选型的时候，才能做到真正的客观和公正，而不会让情绪影响到自己。同样，语言也是一样，有太多的程序员总是喜欢纠缠于语言的对比，如：Java和Perl。哪个刚刚出道的程序员没有争论去类似的话题呢？比如VC++和Delphi等等。争论这些东西只能表明自己的肤浅和浮燥。优秀的程序并不会执着于这些，而是能够理性的分析和理心地面对，从而才能客观地做出正确的选择。

4. 别把自己框在单一的开发环境中。 再一次，正如上面所述，每个程序员都有自己忠爱的工具和技术，有的喜欢老的（比如我就喜欢Vi编辑程序），而有的喜欢新的比如gedit或是Emacs 等。有的喜欢使用像VC++一样的调试器，而我更喜欢GDB命令行方面的调式器。等等等等。程序员在使用什么样的工具上的争论还少吗？到处都是啊。使用什么样的工具本来无所谓，只要你能更好更快地达到你的目的。但是有一点是优秀程序员都应该了解的——那就是应该去尝试一下别的工作环境。没有比较，你永远不知道谁好谁不好，你也永远不知道你所不知道的。

5. 使用版本管理工具管理你的代码。千万不要告诉我你不知道源码的版本管理，如果你的团队开发的源代码并没有版本管理系统，那么我要告诉你，你的软件开发还处于石器时代。赶快使用一个版式本管理工具吧。CVS 是一个看上去平淡无奇的版本工具，但它是被使用最广的版本管理系统，Subversion 是CVS的一个升级版，其正在开始接管CVS的领地。Git 又是一个不同的版本管理工具。还有Visual SourceSafe等。使用什么样的版本管理工具依赖于你的团队的大小和地理分布，你也许正在使用最有效率或最没有效率的工具来管理你的源代码。但一个优秀的程序员总是会使用一款源码版本管理工具来管理自己的代码。如果你要我推荐一个，我推荐你使用开源的Subversion。

6. 是一个优秀的团队成员。 除非你喜欢独奏，除非你是孤胆英雄。但我想告诉你，今天，可能没有一个成熟的软件是你一个人能做的到的，你可能是你团队中最牛的大拿，但这并不意味着你就是好的团队成员。你的能力只有放到一个团队中才能施展开来。你在和你的团队成员交流中有礼貌吗？你是否经常和他们沟通，并且大家都喜欢和你在一起讨论问题？想一想一个足球队吧，你是这个队中好的成员吗？当别人看到你在场上的跑动，当别人看到你的传球和接球和抢断，能受到鼓舞吗？

7. 把你的工作变成文档。 这一条目当然包括了在代码中写注释，但那还仅仅不够，你还需要做得更多。有良好的注释风格的代码是一个文档的基础，他能够让你和你的团队容易的明白你的意图和想法。写下文档，并不仅仅是怕我们忘了当时的想法，而且还是一种团队的离线交流的方法，更是一种知识传递的方法。记录下你所知道的一切会是一个好的习惯。因为，我相信你不希望别人总是在你最忙的时候来打断你问问题，或是你在休假的时候接到公司的电话来询问你问题。而你自己如果老是守着自己的东西，其结果只可能是让你自己长时间地深陷在这块东西内，而你就更本不可以去做更多的事情。包括向上的晋升。你可能以为“教会徒弟能饿死师父”，但我告诉你，你的保守会让你失去更多更好的东西，请你相信我，我绝不是在这里耸人听闻。

8. 注意备份和安全。 可能你觉得这是一个“废话”，你已明白了备份的重要性。但是，我还是要在这里提出，丢失东西是我们人生中的一部份，你总是会丢东西，这点你永远无法避免。比如：你的笔记本电脑被人偷了，你的硬盘损坏了，你的电脑中病毒了，你的系统被人入侵了，甚至整个大楼被烧了，等等，等等。所以，做好备份工作是非常非常重要的事情，硬盘是不可信的，所以定期的刻录光盘或是磁带可能会是一个好的方法，网络也是不可信的，所以小心病毒和黑客，不但使用软件方面的安全策略，你更需要一个健全的管理制度。此外，尽量的让你的数据放在不同的地方，并做好定期（每日，每周，每月）的备份策略。

9. 设计要足够灵活。 可能你的需求只会要求你实现一个死的东西，但是，你作为一个优秀的程序，你应该随时在思考这个死的东西是否可以有灵活的一面，比如把一些参数变成可以配置的，把一些公用的东西形成你的函数库以便以后重用，是否提供插件方面的功能？你的模块是否要以像积木一样随意组合？如果要有修改的话，你的设计是否能够马上应付？当然，灵活的设计可能并不是要你去重新发明轮子，你应该尽可能是使用标准化的东西。所谓灵话的设计就是要让让考虑更多需求之外的东西，把需求中这一类的问题都考虑到，而不是只处理需求中所说的那一特定的东西。比如说，需要需要的屏幕分辨率是800×600，那么你的设计能否灵活于其他的分辨率？程序设计总是需要我们去处理不同的环境，以及未来的趋势。我们需要用动态的眼光去思考问题，而不是刻舟求剑。也许有一天，你今天写的程序就要移植到别的环境中去，那个时候你就能真正明白什么是灵活的设计了。

10. 不要搬起石头砸自己的脚。程序员总是有一种不好的习惯，那就是总是想赶快地完成自己手上的工作。但情况却往往事已愿违。越是想做得快，就越是容易出问题，越是想做得快，就越是容易遗漏问题，最终，程序改过来改过去，按下葫芦起了瓢，最后花费的时间和精力反而更多。欲速而不达。优秀程序员的习惯是前面多花一些时间多作一些调查，试验一下不网的解决方案，如果时间允许，一个好的习惯是，每4个小时的编程，需要一个小时的休息，然后又是4个小时的编码。当然，这因人而异，但其目的就是让你时常回头看看，让你想一想这样三个问题：1）是否这么做是对的？2）是否这么做考虑到了所有的情况？3）是否有更好的方法？想好了再说，时常回头看看走过的路，时常总结一下过去事，会对你有很大的帮助。

以上是十条优秀程序员的习惯或行为规范，希望其可以对你有所帮助。

本文来源于网上phil的BLOG，但我在写作过程中使用了自己的语言和方法重新描述了一下这十条，所以，我希望你在转载的时候能够注明作者和出处以表示对我的尊重。谢谢！

ゞ沉默是金ゞ 2009-03-23 09:59 发表评论

面试技巧:16个经典面试问题回答思路（转）

ゞ沉默是金ゞ — Tue, 10 Mar 2009 03:48:00 GMT

面试过程中，面试官会向应聘者发问，而应聘者的回答将成为面试官考虑是否接受他的重要依据。对应聘者而言，了解这些问题背后的“猫腻”至关重要。本文对面试中经常出现的一些典型问题进行了整理，并给出相应的回答思路和参考答案。读者无需过分关注分析的细节，关键是要从这些分析中“悟”出面试的规律及回答问题的思维方式，达到“活学活用”。

　　问题一：“请你自我介绍一下”

　　思路：

　　1、这是面试的必考题目。

　　2、介绍内容要与个人简历相一致。

　　3、表述方式上尽量口语化。

　　4、要切中要害，不谈无关、无用的内容。

　　5、条理要清晰，层次要分明。

　　6、事先最好以文字的形式写好背熟。

　　问题二：“谈谈你的家庭情况”

　　思路：

　　1、况对于了解应聘者的性格、观念、心态等有一定的作用，这是招聘单位问该问题的主要原因。

　　2、简单地罗列家庭人口。

　　3、宜强调温馨和睦的家庭氛围。

　　4、宜强调父母对自己教育的重视。

　　5、宜强调各位家庭成员的良好状况。

　　6、宜强调家庭成员对自己工作的支持。

　　7、宜强调自己对家庭的责任感。

　　问题三：“你有什么业余爱好?”

　　思路：

　　1、业余爱好能在一定程度上反映应聘者的性格、观念、心态，这是招聘单位问该问题的主要原因。

　　2、最好不要说自己没有业余爱好。

　　3、不要说自己有那些庸俗的、令人感觉不好的爱好。

　　4、最好不要说自己仅限于读书、听音乐、上网，否则可能令面试官怀疑应聘者性格孤僻。

　　5、最好能有一些户外的业余爱好来“点缀”你的形象。

　　问题四：“你最崇拜谁?”

　　思路：

　　1、最崇拜的人能在一定程度上反映应聘者的性格、观念、心态，这是面试官问该问题的主要原因。

　　2、不宜说自己谁都不崇拜。

　　3、不宜说崇拜自己。

　　4、不宜说崇拜一个虚幻的、或是不知名的人。

　　5、不宜说崇拜一个明显具有负面形象的人。

　　6、所崇拜的人人最好与自己所应聘的工作能“搭”上关系。

　　7、最好说出自己所崇拜的人的哪些品质、哪些思想感染着自己、鼓舞着自己问题五：“你的座右铭是什么?”

　　思路：

　　1、座右铭能在一定程度上反映应聘者的性格、观念、心态，这是面试官问这个问题的主要原因。

　　2、不宜说那些医引起不好联想的座右铭。

　　3、不宜说那些太抽象的座右铭。

　　4、不宜说太长的座右铭。

　　5、座右铭最好能反映出自己某种优秀品质。

　　6、参考答案——“只为成功找方法，不为失败找借口”

　　问题六：“谈谈你的缺点”

　　思路：

　　1、不宜说自己没缺点。

　　2、不宜把那些明显的优点说成缺点。

　　3、不宜说出严重影响所应聘工作的缺点。

　　4、不宜说出令人不放心、不舒服的缺点。

　　5、可以说出一些对于所应聘工作“无关紧要”的缺点，甚至是一些表面上看是缺点，从工作的角度看却是优点的缺点。

　　问题七：“谈一谈你的一次失败经历”

　　思路：

　　1、不宜说自己没有失败的经历。

　　2、不宜把那些明显的成功说成是失败。

　　3、不宜说出严重影响所应聘工作的失败经历，

　　4、所谈经历的结果应是失败的。

　　5、宜说明失败之前自己曾信心白倍、尽心尽力。

　　6、说明仅仅是由于外在客观原因导致失败。

　　7、失败后自己很快振作起来，以更加饱满的热情面对以后的工作。

　　问题八：“你为什么选择我们公司?”

　　思路：

　　1、面试官试图从中了解你求职的动机、愿望以及对此项工作的态度。

　　2、建议从行业、企业和岗位这三个角度来回答。

　　3、参考答案——“我十分看好贵公司所在的行业，我认为贵公司十分重视人才，而且这项工作很适合我，相信自己一定能做好。”

　　问题九：“对这项工作，你有哪些可预见的困难?”

　　思路：

　　1、不宜直接说出具体的困难，否则可能令对方怀疑应聘者不行。

　　2、可以尝试迂回战术，说出应聘者对困难所持有的态度——“工作中出现一些困难是正常的，也是难免的，但是只要有坚忍不拔的毅力、良好的合作精神以及事前周密而充分的准备，任何困难都是可以克服的。”
　问题十：“如果我录用你，你将怎样开展工作”

　　思路：

　　1、如果应聘者对于应聘的职位缺乏足够的了解，最好不要直接说出自己开展工作的具体办法，

　　2、可以尝试采用迂回战术来回答，如“首先听取领导的指示和要求，然后就有关情况进行了解和熟悉，接下来制定一份近期的工作计划并报领导批准，最后根据计划开展工作。”

　　问题十一：“与上级意见不一是，你将怎么办?”

　　思路：

　　1、一般可以这样回答“我会给上级以必要的解释和提醒，在这种情况下，我会服从上级的意见。”

　　2、如果面试你的是总经理，而你所应聘的职位另有一位经理，且这位经理当时不在场，可以这样回答：“对于非原则性问题，我会服从上级的意见，对于涉及公司利益的重大问题，我希望能向更高层领导反映。”

　　问题十二：“我们为什么要录用你?”

　　思路：

　　1、应聘者最好站在招聘单位的角度来回答。

　　2、招聘单位一般会录用这样的应聘者：基本符合条件、对这份共组感兴趣、有足够的信心。

　　3、如“我符合贵公司的招聘条件，凭我目前掌握的技能、高度的责任感和良好的饿适应能力及学习能力，完全能胜任这份工作。我十分希望能为贵公司服务，如果贵公司给我这个机会，我一定能成为贵公司的栋梁!”

　　问题十三：“你能为我们做什么?”

　　思路：

　　1、基本原则上“投其所好”。

　　2、回答这个问题前应聘者最好能“先发制人”，了解招聘单位期待这个职位所能发挥的作用。

　　3、应聘者可以根据自己的了解，结合自己在专业领域的优势来回答这个问题。

　　问题十四：“你是应届毕业生，缺乏经验，如何能胜任这项工作?”

　　思路：

　　1、如果招聘单位对应届毕业生的应聘者提出这个问题，说明招聘单位并不真正在乎“经验”，关键看应聘者怎样回答。

　　2、对这个问题的回答最好要体现出应聘者的诚恳、机智、果敢及敬业。

　　3、如“作为应届毕业生，在工作经验方面的确会有所欠缺，因此在读书期间我一直利用各种机会在这个行业里做兼职。我也发现，实际工作远比书本知识丰富、复杂。但我有较强的责任心、适应能力和学习能力，而且比较勤奋，所以在兼职中均能圆满完成各项工作，从中获取的经验也令我受益非浅。请贵公司放心，学校所学及兼职的工作经验使我一定能胜任这个职位。”

　　问题十五：“你希望与什么样的上级共事?”

　　思路：

　　1、通过应聘者对上级的“希望”可以判断出应聘者对自我要求的意识，这既上一个陷阱，又上一次机会。

　　2、最好回避对上级具体的希望，多谈对自己的要求。

　　3、如“做为刚步入社会新人，我应该多要求自己尽快熟悉环境、适应环境，而不应该对环境提出什么要求，只要能发挥我的专长就可以了。”

　　问题十六：“您在前一家公司的离职原因是什么?”

　　思路：

　　1、最重要的是：应聘者要使找招聘单位相信，应聘者在过往的单位的“离职原因”在此家招聘单位里不存在。 2、避免把“离职原因”说得太详细、太具体。

　　3、不能掺杂主观的负面感受，如“太幸苦”、“人际关系复杂”、“管理太混乱”、“公司不重视人才”、“公司排斥我们某某的员工”等。

　　4、但也不能躲闪、回避，如“想换换环境”、“个人原因”等。

　　5、不能涉及自己负面的人格特征，如不诚实、懒惰、缺乏责任感、不随和等。

　　6、尽量使解释的理由为应聘者个人形象添彩。

　　7、如“我离职是因为这家公司倒闭。我在公司工作了三年多，有较深的感情。从去年始，由于市场形势突变，公司的局面急转直下。到眼下这一步我觉得很遗憾，但还要面对显示，重新寻找能发挥我能力的舞台。” 同一个面试问题并非只有一个答案，而同一个答案并不是在任何面试场合都有效，关键在于应聘者掌握了规律后，对面试的具体情况进行把握，有意识地揣摩面试官提出问题的心理背景，然后投其所好

ゞ沉默是金ゞ 2009-03-10 11:48 发表评论

Java应用基础：网友精选25个Java试题分享

ゞ沉默是金ゞ — Wed, 04 Mar 2009 04:27:00 GMT

摘要: 1. float型float f=3.4是否正确? 　答：不正确，应为float f=3.4f 2. 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 　答：是引用传递。 3. 在java中一个类被声明为final类型，表示了什么意思? 　答：表示该类不能被继承，意味着它不能再派生出新的子类，不能作为父类... 阅读全文

ゞ沉默是金ゞ 2009-03-04 12:27 发表评论

Comparator和Comparable比较

ゞ沉默是金ゞ — Thu, 19 Feb 2009 07:36:00 GMT

摘要: 当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。一、Comparator 强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。接口方法： 1 /** *//** 2&... 阅读全文

ゞ沉默是金ゞ 2009-02-19 15:36 发表评论

HTTP/1.1 Cache-Control的理解

ゞ沉默是金ゞ — Tue, 30 Dec 2008 08:49:00 GMT

网页的缓存是由HTTP消息头中的“Cache-control”来控制的，常见的取值有private、no-cache、max-age、must-revalidate等，默认为private。其作用根据不同的重新浏览方式分为以下几种情况：
（1）打开新窗口
如果指定cache-control的值为private、no-cache、must-revalidate，那么打开新窗口访问时都会重新访问服务器。而如果指定了max-age值，那么在此值内的时间里就不会重新访问服务器，例如：
Cache-control: max-age=5
表示当访问此网页后的5秒内再次访问不会去服务器
（2）在地址栏回车
如果值为private或must-revalidate（和网上说的不一样），则只有第一次访问时会访问服务器，以后就不再访问。如果值为no-cache，那么每次都会访问。如果值为max-age，则在过期之前不会重复访问。
（3）按后退按扭
如果值为private、must-revalidate、max-age，则不会重访问，而如果为no-cache，则每次都重复访问
（4）按刷新按扭
无论为何值，都会重复访问

项目中使用过滤器来设置网页的缓存

FilterConfig fc;

    public void doFilter(ServletRequest req, ServletResponse res,
            FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        // set the provided HTTP response parameters
        for (Enumeration e = fc.getInitParameterNames(); e.hasMoreElements();) {
            String headerName = (String) e.nextElement();
            response.addHeader(headerName, fc.getInitParameter(headerName));
        }
        // pass the request/response on
        chain.doFilter(req, response);
    }

配置文件的配置：

<filter>
        <filter-name>NoCachefilter-name>
        <filter-class>filter.CacheFilterfilter-class>
        <init-param>
            <param-name>Cache-Controlparam-name>
            <param-value>no-cache, must-revalidateparam-value>
        init-param>
    filter>
    <filter>
        <filter-name>CacheForWeekfilter-name>
        <filter-class>filter.CacheFilterfilter-class>
        <init-param>
            <param-name>Cache-Controlparam-name>
            <param-value>max-age=604800param-value>
        init-param>
    filter>

    <filter-mapping>
        <filter-name>CacheForWeekfilter-name>
        <url-pattern>*.jsurl-pattern>
    filter-mapping>
    <filter-mapping>
        <filter-name>CacheForWeekfilter-name>
        <url-pattern>*.cssurl-pattern>
    filter-mapping>
    <filter-mapping>
        <filter-name>CacheForWeekfilter-name>
        <url-pattern>*.gifurl-pattern>
    filter-mapping>

上述设置保存了1周的缓存。

ゞ沉默是金ゞ 2008-12-30 16:49 发表评论

BlogJava-ゞ沉默是金ゞ-随笔分类-Java SE

jvm学习笔记

ThreadPoolExecutor usage summary

Part 13: java.util.concurrent - Atomic Variables

Part 12: java.util.concurrent : SingleThreadPool Example

Part 11: java.util.concurrent - CachedThreadPool Example

Part 10: java.util.concurrent - ScheduledThreadPool Example

Part 9: java.util.concurrent : FixedThreadPool Example

Part 8: java.util.concurrent - "Executors" Factory Threads Pool

Part 7: java.util.concurrent - invokeAll via ExecutorService

Part 6: java.util.concurrent - Lock and Condition Object

Part 5: java.util.concurrent - Submit Callable< T > via ExecutorService

Part 4: java.util.concurrent - Submit Runnable via ExecutorService

Part 3:java.util.concurrent- ExecutorService Interface

Part 2: java.util.concurrent - Future

Part 1: java.util.concurrent - Runnable Vs Callable in Java

文件追加内容实例

文件读取实例

How to Create Client/Server Keystores using Java Keytool

Using Java Reflection

tomcat 配置用户

Eclipse中10个比较有用的快捷键组合(转)

用 * 打印出各种图形

jconsole

再谈类的初始化

类的 初始化顺序

优秀程序员的十个习惯(摘)

面试技巧:16个经典面试问题回答思路（转）

Java应用基础：网友精选25个Java试题分享

Comparator和Comparable比较

HTTP/1.1 Cache-Control的理解

类的初始化顺序