14，线程1-定义线程的方式

1,继承Thread类创建线程:

public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  
 
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();  

2,实现Runnable接口创建线程

public class AccountingSync implements Runnable
{
    //共享资源(临界资源)
     static int i=0;

    /**
     * synchronized 修饰实例方法
     */
    public  void increase(){
        synchronized(this)
        {
            i++;
        }

    }
    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        t1.join(1);
        t2.join(100);
        System.out.println(i);
    }

3，实现Callable接口通过FutureTask包装器来创建Thread线程

package com.xiancheng;
/**
 *Callable方式
 *
 *获取当前线程的对象的方法是：Thread.currentThread()；
 */
import java.util.concurrent.Callable;

@SuppressWarnings("hiding")
public class Tickets<Object> implements Callable<Object>{

    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }

}

package com.xiancheng;
/**
 *Callable方式
 */
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableTest {

    public static void main(String[] args) {
            Callable<Object> oneCallable = new Tickets<Object>();
            Callable<Object> twoCallable = new Tickets<Object>();
            
            FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
            FutureTask<Object> twoTask = new FutureTask<Object>(twoCallable);
            
            Thread t1 = new Thread(oneTask);
            Thread t2 = new Thread(twoTask);

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

            t1.start();
            t2.start();


    }

}

4，线程池

package com.xiancheng;

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

/**
 * 线程池方式
 * ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征，还有Future接口也是属于这个框架，有了这种特征得到返回值就很方便了。 
通过分析可以知道，他同样也是实现了Callable接口，实现了Call方法，所以有返回值。这也就是正好符合了前面所说的两种分类

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的，即：线程无返回结果，get方法会一直等待。
 */
public class Xianchengchi {

     private static int POOL_NUM = 10;       //线程池数量
    
    public static void main(String[] args) throws InterruptedException{
          ExecutorService executorService = Executors.newFixedThreadPool(5);  
            for(int i = 0; i<POOL_NUM; i++)  
            {  
                RunnableThread thread = new RunnableThread();

                //Thread.sleep(1000);
                executorService.execute(thread);  
            }
            //关闭线程池
            executorService.shutdown(); 

    }

}

线程池 已学习

12，新特征-有返回值的线程（实现Callable接口）（了解）

13，新特征-锁（上）
（在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集

中在java.util.concurrent.locks包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。）

14，锁对象：读写锁

15，Java线程：新特征-信号量（了解）

16，Java线程：新特征-条件变量（了解）

17，Java线程：新特征-原子量（了解）

18，Java线程：新特征-障碍器（了解）
java5中，添加了障碍器类，为了适应一种新的设计需求，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有

子任务都执行完成时候，才能执行主任务，这时候，就可以选择障碍器了。