关于java中的线程的学习

1：   关于异步编程的callback实现。

主要实现为：通过定义callback接口，在主线程中重新开一个线程去执行某项任务，然后任务完成后。再回调主线程来继续下面的逻辑：

代码：

接口 ：callback(还以为这个是JDK的，哪知道自己写都行。。。没那么神秘的！)

public interface Callback 

{ 

public void execute(Object... objects); 

}

主线程类：

/* 

* 简单本地发送异步消息的类 * * 

*/ 

public class Local implements Callback, Runnable 

{

/**

  * 远程接收消息的类，模拟point-to-point

  */

private Remote remote;

/**

  * 发送出去的消息

  */

private String message;

public Local(Remote remote, String message) {

super();

this.remote = remote;

this.message = message;

}

/**

  * 发送消息

  */

public void sendMessage() {

/** 当前线程的名称 **/

System.out.println(Thread.currentThread().getName());

/** 创建一个新的线程发送消息 **/

Thread thread = new Thread(this);

thread.start();

/** 当前线程继续执行 **/

System.out.println("Message has been sent by Local~!");

}

/**

  * 发送消息后的回调函数

  */

public void execute(Object... objects) {

/** 打印返回的消息 **/

System.out.println(objects[0]);

/** 打印发送消息的线程名称 **/

System.out.println(Thread.currentThread().getName());

/** 中断发送消息的线程 **/

Thread.interrupted();

}

public void run() {

remote.executeMessage(message, this);

}

public static void main(String[] args) {

Local local = new Local(new Remote(), "Hello");

local.sendMessage();

}

远程实现类，异步回调的：

public class Remote {

/**

  * 处理消息

  * 

  * @param msg

  *            接收的消息

  * @param callBack

  *            回调函数处理类

  */

public void executeMessage(String msg, Callback callback) {

/** 模拟远程类正在处理其他事情，可能需要花费许多时间 **/

  Thread.sleep(2);

/** 处理完其他事情，现在来处理消息 **/

System.out.println(msg);

System.out.println("I hava executed the message by Local");

/** 执行回调 **/

callback.execute(new String[] { "Nice to meet you~!" });

}

这种方法感觉不怎么好用；

 本地主线程local类实现了callback接口和线程runnable接口。该类的业务逻辑为sendMessage；

 在该方法中，通过新建一个线程来实现，新建的线程start就会执行remote的异步方法。

Thread thread = new Thread(this);

thread.start();

/** 当前线程继续执行 **/

System.out.println("Message has been sent by Local~!");

 remote可以异步的执行，当前的主线程也能继续向下执行。当remote执行完应该的业务逻辑  后，就会调用callback接口的execute方法。从而实现回调。

 这算是一种代码的结构模式。实现异步的模式。

2：关于线程 的join学习

线程的join方法应该就是一种实现同步的方法。按照我的理解就是允许主线程在执行过程中，让另外一个线程也同步执行。因为一般情况下，重新new一个线程，然后用这个线程的start方法，主线程会不管这个new出来的线程，接着向下执行的。

示例代码：

public class JoinTest {

public static void main(String[] args) {

Thread t = new Thread(new RunnableImpl());

t.start();

try {

System.out.println("BeginJoin");

t.join(1000);

System.out.println("joinFinish");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

class RunnableImpl implements Runnable {

public void run() {

try {

System.out.println("Begin sleep");

Thread.sleep(1000);

System.out.println("End sleep");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

t.join(XX)这个XX 是等待的时间。如果设为0就表示要一直等到t这个线程死亡。

3：关于线程 的Future学习

        按照我的理解，future其实就是由返回值的多线程的操作。

       Future的接口中，有一个get()方法。也就是用来获得线程返回值的方法。

       使用future来进行这种实现，可以用future的实现接口类FutureTask，该类同时实现了Future接口和Runnable接口。

public class ConcurrentImpl {

public static void main(String[] args) throws InterruptedException,

Exception {

FutureTask fr = new FutureTask(new Returnresult());

new Thread(fr).start();

// main线程无需等待，不会被阻塞。

// 模仿 干自己的活 2s。

Thread.sleep(2000);

// 估计算完了吧 取取试试。

System.out.println("过来2s了，看看有结果吗？");

if (!fr.isDone()) {

System.out.println("还没有完成呢！ 继续干自己活吧！");

}

// 模仿 干自己的活 4s。

Thread.sleep(4000);

System.out.println("过来4s了，看看有结果吗？");

if (fr.isDone()) {

System.out.println("完成了！");

System.out.println("Result：" + fr.get());

}

}

}

public class Returnresult implements Callable {

public Object call() throws Exception {

// 模仿大量耗时计算后（5s）返回结果。

System.out.println("GenerateResultThread开始进行计算了！");

Thread.sleep(1000);

return "ResultByGenerateResultThread";

}

}

  使用future后，就可以进行异步，接着处理自己的事情，然后过一会看看处理完没，处理完了再进行相关事情的处理。但是不会像callback那样，另外一个线程执行完逻辑后自动通知主线程处理完成了。

各种方式都各有优缺点~~~