今天完成的事情：

看学习资料，学习Tuscany，学习多线程。

package ExtendAndImplments;

import java.util.Random;

/**
 * 这里是实现Runable接口，这里创建了一个dog对象，同时有3个新手玩家去killdog
 * 3个线程对象共享一个内存空间
 *
 * java中类只能继承某一个类，但是可以实现多个接口。
 * 实现Runable接口，多个线程共享同一个内存资源。
 *
 */
public class ImplementsDemo{
    public static void main(String[] args) {
        KillDog dog = new KillDog();
        new Thread(dog).start();
        new Thread(dog).start();
        new Thread(dog).start();
    }

}
class KillDog implements Runnable{
    int num = 50;
    public void run(){
        for(int i=50;i>0;i--){
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + "杀死了第" + num + "鸡");
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    num--;
                }
        }
    }
}



/**
 * 继承父类的方法。
 * 每创建一个（new KillChicken）对象，就会在堆内存中开辟空间，该空间存放自己的鸡数量，为50。
 *
 * java中类只能继承某一个类，但是可以实现多个接口。
 * 继承Thread类，多个线程无法共享同一个内存。但当换做静态资源时，可以实现。
 */
package ExtendAndImplments;

class KillChicken   extends Thread{
     static int num = 50;
    public KillChicken (String name){
    }
    public void run(){
        for(int i=50;i>0;i--){
            if(num>0) {
                System.out.println(super.getName() + "杀死了第" + num--+ "鸡");
            }
        }
    }
}

public class ExtendsDemo {
    public static void main(String[] args) {
        new KillChicken("A").start();
        new KillChicken("A").start();
        new KillChicken("A").start();
    }
}



package SynchronousLock;

/**
 * synchronized 安全但是损耗性能  尽量减小synchronized的作用域
 */
public class Synchronous {

    public static void main(String[] args) {
        KillDog dog = new KillDog();
        new Thread(dog).start();
        new Thread(dog).start();
        new Thread(dog).start();
    }
}
class KillDog implements Runnable{
    int num = 50;
    public void run(){
        for(int i=50;i>0;i--){
            synchronized (this) {
                if (num > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "杀死了第" + --num + "鸡");
                }
            }
        }
    }
}

然后是框架：
在网上看了一些资料，本想去官网下载Demo。可是发现这个已经没有使用这门技术了。
然后找了一些资料：
<composite xmlns="http://docs.oasis-open.org/ns/opencsa/sca/200912"
           xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.1"
           targetNamespace="http://st"
           name="st">

    <component name="CalculatorServiceComponent">
        <implementation.java class="com.service.impl.CalculatorServiceImpl"/>
        <reference name="addService" target="AddServiceComponent" />
        <reference name="subtractService" target="SubtractServiceComponent" />
        <reference name="multiplyService" target="MultiplyServiceComponent" />
        <reference name="divideService" target="DivideServiceComponent" />
    </component>

    <component name="AddServiceComponent">
        <implementation.java class="com.service.impl.AddServiceImpl"/>
    </component>

    <component name="SubtractServiceComponent">
        <implementation.java class="com.service.impl.SubtractServiceImpl"/>
    </component>

    <component name="MultiplyServiceComponent">
        <implementation.java class="com.service.impl.MultiplyServiceImpl"/>
    </component>

    <component name="DivideServiceComponent">
        <implementation.java class="com.service.impl.DivideServiceImpl"/>
    </component>

</composite>
这一段表头约束会报红，不过没关系。
Tuscany 与spring 相结合就是把service的接口暴露出来。
 
但是呢现在这门技术已经退休了。

明天计划的事情：

看一些复盘相关的资料
遇到的问题：

官网没有学习资料。
收获：

多线程的学习。如何保证线程安全。通过实现Runable接口 或者继承Thread类 来实现多线程。