package ThreadDemo;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
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;
//懒汉式单例,线程不安全的,使用同步机制
//对于一般的方法内,使用同步代码块,可以考虑使用this
//对于静态方法而言,使用当前类本身充当锁
/*JAVA类首次装入时,会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的,
* 静态成员变量和静态初始化块级别相同,非静态成员变量和非静态初始化块级别相同。
先初始化父类的静态代码--->初始化子类的静态代码-->
初始化父类的非静态代码--->初始化父类构造函数--->
初始化子类非静态代码--->初始化子类构造函数
*/
public class TestSingleton {
public static void main(String[] args) throws Exception {
List<Singleton> singletonlist= new ArrayList<Singleton>();
Set<Singleton> singletonSet= new HashSet<Singleton>();
List<Callable> callableList= new ArrayList<Callable>();
List<Future> futureList= new ArrayList<Future>();
// 获取多线程的返回值
// 1创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(1000);
for(int i=0;i<1000;i++){
//2创建有返回值的任务线程
Callable c1 = new ThreadTestSingle();
// 3执行任务并获取Future对象
Future f1 = pool.submit(c1);
//4从Future对象上获取任务的返回值
singletonlist.add((Singleton) f1.get());
singletonSet.add((Singleton) f1.get());
}
System.out.println(singletonlist.size());
System.out.println(singletonlist.get(0)==singletonlist.get(1));
System.out.println(singletonSet.size());
// 5关闭线程池
pool.shutdown();
}
}
class Singleton {
private Singleton() {
}
private static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
/* 有返回值的多线程 */
class ThreadTestSingle implements Callable {
@Override
public Singleton call() throws Exception {
// TODO Auto-generated method stub
return Singleton.getInstance();
}
}
执行结果是:
1000
true
1
本来想循环创建多线程,但是因为for循环是先后的,所有,其实只是第一个循环去创建的,就当学习下有返回值的多线程吧。。。 如何用for循环去验证?应该不好使吧。。
倒是下面的 这种,基本都能测试出来,不是相同对象
package ThreadDemo;
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;
//懒汉式单例,线程不安全的,使用同步机制
//对于一般的方法内,使用同步代码块,可以考虑使用this
//对于静态方法而言,使用当前类本身充当锁
/*JAVA类首次装入时,会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的,
* 静态成员变量和静态初始化块级别相同,非静态成员变量和非静态初始化块级别相同。
先初始化父类的静态代码--->初始化子类的静态代码-->
初始化父类的非静态代码--->初始化父类构造函数--->
初始化子类非静态代码--->初始化子类构造函数
*/
public class TestSingleton2 {
public static void main(String[] args) throws Exception {
//获取多线程的返回值
//1创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//2创建两个有返回值的任务
Callable c1 = new ThreadTestSingle();
Callable c2 = new ThreadTestSingle();
//3执行任务并获取Future对象
Future f1 = pool.submit(c1);
Future f2 = pool.submit(c2);
//4从Future对象上获取任务的返回值,并输出到控制台
Singleton singleton1=(Singleton) f1.get();
Singleton singleton21=(Singleton) f2.get();
System.out.println();
System.out.println(singleton1==singleton21);
//5关闭线程池
pool.shutdown();
}
}
class Singleton{
private Singleton(){}
private static Singleton instance=null;
public static Singleton getInstance(){
/* if (instance == null) {
synchronized (Singleton.class) {
if(instance==null)
instance = new Singleton();
}
}*/
if(instance==null){
instance = new Singleton();
}
return instance;
}
}
/*有返回值的多线程*/
class ThreadTestSingle implements Callable{
public Singleton call() throws Exception {
// TODO Auto-generated method stub
return Singleton.getInstance();
}
}
打印结果大多数都是false