cugxchen / cugxchen.github.io Goto Github PK

public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			
			public void run() {
				System.out.println("currentThreadName=" + Thread.currentThread());
			}
		});
		
		thread.run();//将run()方法当普通方法调用，不会创建新线程
		thread.run();//将run()方法当普通方法调用，可以重复调用
		
		thread.start();//创建新线程，并自动调用run()方法
		//thread.start();//多次调用start()抛异常
	}

                            synchronized实例1
                  线程锁定相同对象，其他线程对该synchronized区域不能访问
class MyRunable implements Runnable {
    
    public void run() {
        synchronized(this) {
            try {  
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100); // 休眠100ms
                    System.out.println(Thread.currentThread() + " loop " + i);  
                }
            } catch (InterruptedException ie) {  
            }
        }  
    }
}

public class ThreadSynchronized {

    public static void main(String[] args) {  
        Runnable runnable = new MyRunable();     // 新建“Runnable对象”

        Thread t1 = new Thread(runnable, "t1");  // 新建“线程t1”, t1是基于demo这个Runnable对象
        Thread t2 = new Thread(runnable, "t2");  // 新建“线程t2”, t2是基于demo这个Runnable对象
        t1.start();                          // 启动“线程t1”
        t2.start();                          // 启动“线程t2” 
    } 
}

                             synchronized示例2
               线程锁定相同对象，其他线程对该对象的其他synchronized区域也不能访问
class Count {

    // 含有synchronized同步块的方法
    public void synMethod() {
        synchronized(this) {//锁定Count对象实例
            try {  
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100); // 休眠100ms
                    System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);  
                }
            } catch (InterruptedException ie) {  
            }
        }  
    }

    // 也包含synchronized同步块的方法
    public void synMethod2() {
        synchronized(this) {//锁定Count对象实例
            try {  
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " synMethod2 loop " + i);  
                }
            } catch (InterruptedException ie) {  
            }
        }
    }
}

public class ThreadSynchronizedTwo {

    public static void main(String[] args) {  
        final Count count = new Count();
        // 新建t1, t1会调用“count对象”的synMethod()方法
        Thread t1 = new Thread(
                new Runnable() {
                    public void run() {
                        count.synMethod();
                    }
                }, "t1");

        // 新建t2, t2会调用“count对象”的nonSynMethod()方法
        Thread t2 = new Thread(
                new Runnable() {
                    public void run() {
                        count.synMethod2();
                    }
                }, "t2");  


        t1.start();  // 启动t1
        t2.start();  // 启动t2
    } 
} 

synchronized示例3
线程锁定相同对象，其他线程对该对象的非synchronized区域可以访问
class MyCount {

    // 含有synchronized同步块的方法
    public void synMethod() {
        synchronized(this) {
            try {  
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100); // 休眠100ms
                    System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);  
                }
            } catch (InterruptedException ie) {  
            }
        }  
    }

    // 非同步的方法
    public void nonSynMethod() {
        try {  
            for (int i = 0; i < 5; i++) {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);  
            }
        } catch (InterruptedException ie) {  
        }
    }
}

public class ThreadSynchronizedThree {

    public static void main(String[] args) {  
        final MyCount count = new MyCount();
        // 新建t1, t1会调用“count对象”的synMethod()方法
        Thread t1 = new Thread(
                new Runnable() {
                    public void run() {
                        count.synMethod();
                    }
                }, "t1");

        // 新建t2, t2会调用“count对象”的nonSynMethod()方法
        Thread t2 = new Thread(
                new Runnable() {
                    public void run() {
                        count.nonSynMethod();
                    }
                }, "t2");  


        t1.start();  // 启动t1
        t2.start();  // 启动t2
    } 
}

synchronized示例4
线程锁定不同对象，对不同对象的synchronized区域可以访问
class MyThread extends Thread {
    
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        synchronized(this) {
            try {  
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100); // 休眠100ms
                    System.out.println(Thread.currentThread().getName() + " loop " + i);  
                }
            } catch (InterruptedException ie) {  
            }
        }  
    }
}

public class ThreadSynchronizedFour {

    public static void main(String[] args) {  
        Thread t1 = new MyThread("t1");  // 新建“线程t1”
        Thread t2 = new MyThread("t2");  // 新建“线程t2”
        t1.start();                      // 启动“线程t1”
        t2.start();                      // 启动“线程t2” 
    } 
}

pulbic class Something {
    public synchronized void syncA(){}
    public synchronized void syncB(){}
    public static synchronized void staticSyncA(){}
    public static synchronized void staticSyncB(){}
}   
 Something x = new Something();
Something y = new Something();

                      //Wait()使当前线程等待
class TestThread extends Thread{
	 public TestThread(String name) {
	     super(name);
	 }
	
	 public void run() {
	     synchronized (this) {
	         System.out.println(Thread.currentThread().getName()+" call notify()");
	         // 唤醒当前的wait线程
	         notify();
	     }
	 }
}

public class WhichThreadWait {

 public static void main(String[] args) {

	 TestThread t1 = new TestThread("t1");

     synchronized(t1) {
         try {
             // 启动“线程t1”
             System.out.println(Thread.currentThread().getName()+" start t1");
             t1.start();

             // 主线程等待t1通过notify()唤醒。
             System.out.println(Thread.currentThread().getName()+" wait()");
             t1.wait();//为何这里是主线程等待，而不是t1线程等待？

             System.out.println(Thread.currentThread().getName()+" continue");
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }
}

唤醒所有在此监视器上等待的线程
public class WaitAndNotify {
    private static Object obj = new Object();
    public static void main(String[] args) {
    	  MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");
    	  MyThread t3 = new MyThread("t3");
        t1.start();
        t2.start();
        t3.start();

        try {
            System.out.println(Thread.currentThread().getName()+" sleep(3000)");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        synchronized(obj) {
            System.out.println(Thread.currentThread().getName()+" notifyAll()");
            obj.notifyAll();//唤醒所有wait()线程
            //obj.notify();//唤醒单个wait()线程
        }
    }

    static class MyThread extends Thread{
        public MyThread(String name){
            super(name);
        }

        public void run() {
            synchronized (obj) {
                try {
                    // 打印输出结果
                    System.out.println(Thread.currentThread().getName() + " wait");
                    //当前线程进入等待状态，释放锁
                    obj.wait();
                    // 打印输出结果
                    System.out.println(Thread.currentThread().getName() + " continue");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class JoinTest{ 

 public static void main(String[] args){ 
     try {
         ThreadA t1 = new ThreadA("t1"); // 新建“线程t1”

         t1.start();                     // 启动“线程t1”
         t1.join();                        //“主线程main()会等待"线程t1"完成”
         System.out.printf("%s finish\n", Thread.currentThread().getName()); 
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 } 

 static class ThreadA extends Thread{

     public ThreadA(String name){ 
         super(name); 
     } 
     public void run(){ 
         System.out.printf("%s start\n", this.getName()); 

         // 延时操作
         try {
			sleep(3000);
		} catch (Exception e) {
			// TODO: handle exception
		}

         System.out.printf("%s finish\n", this.getName()); 
     } 
 } 
}

class MyThreadTest extends Thread{
	public MyThreadTest(String namString){
		super(namString);
	}
	
	public MyThreadTest(Runnable runnable, String namString){
		super(runnable, namString);
	}
	
	
	@Override
	public void run() {
		super.run();//需要调用super.run()方法，否则传入的Runnable实例无法执行
		
		System.out.println(Thread.currentThread() + " MyThread run method");
	}
}


public class ThreadAndRunnable {
    public static void main(String[] args) {
    	Runnable runnable = new Runnable() {
			
			public void run() {
				System.out.println(Thread.currentThread() + " Runnable run method");
			}
		};
		
		//直接创建Thread实例，Runnable创建线程执行体
		System.out.println("直接创建Thread实例t1，Runnable创建线程执行体");
		Thread thread1 = new Thread(runnable, "t1");
		thread1.start();
		
		//自定义类继承Thread，创建线程实例
		System.out.println("自定义类继承Thread，创建线程实例t2");
		MyThreadTest thread2 = new MyThreadTest("t2");
		thread2.start();
		
		//既自定义类继承Thread，又使用了Runnable接口
		System.out.println("既自定义类继承Thread，又使用了Runnable接口，创建线程t3");
		MyThreadTest thread3 = new MyThreadTest(runnable, "t3");
		thread3.start();	
    }
}

public class AppManager{
	private static volatile AppManager instance = null;
	private Context mContext;

	private AppManager(Context context){
		this. mContext = context;
    }

	public static AppManager getInstance(Context context){
		if(null == instance){
			synchronized(AppManager.class){
				if(null == instance){
				    instance = new AppManager(context);
				}
	        }
	     }
	     return instance;
	   }
}

public class OuterClassActivity extern Activity{
	private static Inner mInner = null;

	@Override
	protected void onCreate (Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

		if(null == mInner){
			mInner = new Inner();//创建静态实例
		}
	}
	
	private class Inner{//非静态内部类
		//TODO
	}
}

private static class Inner{
	private WeakReference<OuterClassActivity> mActivity;
	
	public Inner(OuterClassActivity activity){
		mActivity = new WeakReference<OuterClassActivity>( activity); 
	}
}

public class MainActivity extends AppCompatActivity {
    private Handler mHandler = new Handler() {
    	
	    @Override
	    public void handleMessage(Message msg) {
	         //TODO
	    }
    };
}

public class MainActivity extends AppCompatActivity {
    private Handler mHandler = new MyHandler (this);

    private  static class MyHandler extern Handler{
	    private WeakReference<Context> softRefContext;
	    public MyHandler(Context context) {
	    	softRefContext = new WeakReference<Context>(context);
	    }
	    
	   @Override
	   public void handleMessage(Message msg) {
	         //TODO
	   }
   };


	@Override
	protected void onDestroy() {
		if (mHandler != null){
			 mHandler.removeCallbacksAndMessages(null);
			 mHandler = null;
		}
		super.onDestroy();
	}
}

new Thread(new Runnable() {
    @Override
    public void run() {
        Log.i(TAG, "线程创建成功，正在执行线程程序");
        SystemClock.sleep(30*1000);
        //TODO
    }
}).start();

static class MyRunnable implements Runnable{
    @Override
    public void run() {
        Log.i(TAG, "线程创建成功，正在执行线程程序");
        SystemClock.sleep(30*1000);
    }
}
//--------------------------------------------------------------------------
new Thread(new MyRunnable()).start();

public class AIDLRemoteService extends Service {
	public final String TAG = this.getClass().getSimpleName();
	
   /*
   * Service生命周期方法
   */
    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreate");
    }

    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy");
        super.onDestroy();
    }

   /*
   * 创建AIDL服务Binder
   */
	private IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub(){
        @Override
        public String myAidlTest() throws RemoteException {//ADIL文件中定义的方法名
            return "Hello AIDL test";
        }
    };

	/*
	* Binder方法重载
	*/
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onBind");
        return mBinder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "onUnbind");
        return super.onUnbind(intent);
    }
}

public class ClientMainActivity extends Activity{
	public final String TAG = this.getClass().getSimpleName();
	private IMyAidlInterface mConnectIMyAidlInterface;//通过该实例调用AIDL方法
	private final static AIDL_INTENT_NAME= "aidltestservice.AIDLRemoteService";
	    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.i(TAG,"onCreate");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_client_main);
        mContext = this;
        bindAidlService();
    }

   @Override
   protected void onResume() {
        Log.i(TAG,"onResume");
        try{
            String string = mConnectIMyAidlInterface.myAidlTest();//调用AIDL接口，返回的是"Hello AIDL test"
        }
       catch (RemoteException e){
           Log.w(TAG, "服务调用失败");
        }
   }
    
    private void bindAidlService(){
        Intent intent = new Intent(AIDL_INTENT_NAME);
        boolean ret = bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
        Log.i(TAG, "创建AIDL链接是否成功:"+ret);
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder binder){
            mConnectIMyAidlInterface = IMyAidlInterface.Stub.asInterface(binder);
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mConnectIMyAidlInterface = null;
        }
    };
}

/*
 * 演示 对象在finalize()方法中自救（不建议这么使用）
 */
public class FinalizeEscapeGC{
	public static FinalizeEscapeGC saveMyself = null;
	
	public void isAlive() {
		System.out.println("我还活在！");
	}
	
	@Override
	protected void finalize() throws Throwable{
		super.finalize();
		System.out.println("finalize() 方法被执行，我来拯救自己!");
		FinalizeEscapeGC.saveMyself = FinalizeEscapeGC.this;
	}
	
	public static void main(String[] args) throws InterruptedException {
    	FinalizeEscapeGC.saveMyself = new FinalizeEscapeGC();
    	//对象第一次拯救自己，拯救成功
    	FinalizeEscapeGC.saveMyself = null;
    	System.gc();
    	Thread.sleep(100);
    	System.out.println("第一次成功拯救自己");
    	if (FinalizeEscapeGC.saveMyself != null) {
    		FinalizeEscapeGC.saveMyself.isAlive();
		}else {
			System.out.println("FinalizeEscapeGC 对象已死");
		}
    	
       	//对象第二次拯救自己，拯救失败
    	FinalizeEscapeGC.saveMyself = null;
    	System.gc();
    	Thread.sleep(100);
    	System.out.println("第二次拯救自己失败");
    	if (FinalizeEscapeGC.saveMyself != null) {
    		FinalizeEscapeGC.saveMyself.isAlive();
		}else {
			System.out.println("FinalizeEscapeGC 对象已死");
		}
    }
}

public String nullStringTest(){
    String s = null;
    s += "abc";
    return s;
}

public void stringPool(){
    String a="hello";
    String b="hell";
    String c=b+"o";
    String d="hell"+"o";

    System.out.println(a == b+new String("o"));
    System.out.println(a == c);
    System.out.println(a == d);
}

s += "abc";

StringBuilder tmp = new StringBuilder();
tmp.append(String.valueOf((Object)null));
tmp.append("abc");
s = tmp.toString();

String str1 = "abc";
String str2 = new String("abcd");

private static int LOOP_TIMES = 10000;
private Random ran = new Random();

public void loopString(){
    String string = "";
    for (int i=0; i<LOOP_TIMES; i++){
        string += ran.nextInt();
    }
}

public void loopStringBuild(){
    StringBuilder stringBuilder = new StringBuilder();
    for (int i=0; i<LOOP_TIMES; i++){
        stringBuilder.append(ran.nextInt());
    }
}

public void loopStringBuffer(){
    StringBuffer stringBuffer = new StringBuffer();
    for (int i=0; i<LOOP_TIMES; i++){
        stringBuffer.append(ran.nextInt());
    }
}

public class ParentClass {
	static{
		System.out.println("ParentClass init");
	}
	
	public static int value = 123;
	
	public ParentClass() {
		System.out.println("new ParentClass instance");
	}
}

public class SubClass extends ParentClass{
	static{
		System.out.println("SubClass init");
	}
	
	public SubClass() {
		System.out.println("new SubClass instance");
	}
}

public class ConstClass {
	static{
		System.out.println("ConstClass init");
	}
	public static final String HELLO_WORLD = "hello world";
}

//为防止前面运行的代码影响后面代码的执行结果，模块1、2、3分别运行
public static void main(String[] args) {
	/* 模块1
	 * 输出：ParentClass init
             123
	 *  对于静态字段，只有直接定义这个字段的类才会初始化，因此子类引用父类定义的静态字段，只会触发父类的初始化，而子类不会初始化
	 */
	System.out.println(SubClass.value);
	System.out.println("-------------------------------------");
		
	/*  模块2
	 *  输出：-------------------------------------
              ParentClass init
	 *  通过数组定义来引用类，不会触发此类的初始化.(数组类本身不是通过类加载器创建，它是由Java虚拟机直接创建)
	*/
	ParentClass[] parentClasses = new ParentClass[10];
	System.out.println("-------------------------------------");
	ParentClass objClass = parentClasses[0];
	objClass.value = 555;//调用数组类的静态字段，触发类的初始化
		
/*  模块3
	*  输出：hello world
	*  
 *  常量在编译时就放入常量池，本质上没有直接引用定义常量的类，不会触发定义常量的类的初始化
	*/
		System.out.println(ConstClass.HELLO_WORLD);
	}

/*
 *  演示 类的<clinit>()方法在多线程环境被自动加锁、同步
 *  输出：    Thread[main,5,main] init class            5秒之后才会有下面的打印
			Thread[thread1,5,main]---start
			Thread[thread2,5,main]---start
			Thread[thread2,5,main]  实例构造方法
			Thread[thread2,5,main]---run over!
			Thread[thread1,5,main]  实例构造方法
			Thread[thread1,5,main]---run over!
 */
public class ClassLoad {
    static{
    	if (true) {
			System.out.println(Thread.currentThread() +" init class");

			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
    }
    
    public ClassLoad() {
    	System.out.println(Thread.currentThread() +"  实例构造方法");
	}
    
    public static void main(String[] args) {
    	
		Runnable runnable = new Runnable() {
			
			public void run() {
				System.out.println(Thread.currentThread() + "---start");
				ClassLoad classLoad = new ClassLoad();
				System.out.println(Thread.currentThread() + "---run over!");
			}
		};
		
		Thread thread1 = new Thread(runnable, "thread1");
		Thread thread2 = new Thread(runnable, "thread2");
		thread1.start();
		thread2.start();
	}
}

protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
//首先检查请求的类是否已经被加载过，已加载直接返回
    Class<?> clazz = findLoadedClass(className); 
    if (clazz == null) {//未加载过
        try {
            clazz = parent.loadClass(className, false);//委派父类加载器加载
        } catch (ClassNotFoundException e) {
            // Don't want to see this.
        }

        if (clazz == null) {//父类加载器无法加载，自身findClass方法进行类加载
            clazz = findClass(className);
        }
    }

    return clazz;
}

public class HelloWorld{
	    public static void main(String[] args){
	        System.out.println("Hello world");
	    }
}

public class MyClass {
	private String nameString;
	
	public String toString() {
		return "我叫 " + "MyClass" + ", 我是由 " + getClass().getClassLoader().getClass()+" 加载进来";
	} 
}

public class MyClassLoader extends ClassLoader{
	private String classPathString;
	private ClassLoader parentClassLoader;
	
	public MyClassLoader(String path) {
		this(path, getSystemClassLoader());
	}
	
	public MyClassLoader(String path, ClassLoader parClassLoader) {
		super(parClassLoader);
		this.classPathString = path;
		this.parentClassLoader = parClassLoader;
	}
	
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		String classNameString = name.substring(name.lastIndexOf(".")+1);//不包含最后一个“.”所有+1
		String filePathString = classPathString + classNameString + ".class";
		File file = new File(filePathString);
		
		System.out.println("MyClassLoader.findClass()   package=" + name + "  filePathString=" + filePathString);
		try {
			byte[] bytes = getClassBytes(file);
			//把二进制字节流组成的文件转换为一个java.lang.Class
			Class<?> clazz = this.defineClass(name, bytes, 0, bytes.length);
			return clazz;
		} catch (Exception e) {
			// TODO: handle exception
		}
		
		return super.findClass(name);
	}
	
	/*
	 * 重载loadClass方法可能会破坏双亲委派机制，不建议重载该方法，除非特殊需求
	 *
	 */
	@Override
	public Class<?> loadClass(String name) throws ClassNotFoundException {
	   Class<?> clazz = findLoadedClass(name);//首先检查是否被加载过
	   if (clazz == null) {//未加载过，
		   try {
			   if (parentClassLoader != null) {
				   clazz = parentClassLoader.loadClass(name);//委派父类加载加载
			   }
		   } catch (ClassNotFoundException e) {
				// TODO: handle exception
				//e.printStackTrace();
		   }
		   
		   if (clazz == null) {//父加载器无法加载，自身加载
			   clazz = findClass(name);
		   }
	   }
	   
	   /*
	    * 如果直接用自己加载类，会提示无法"java.lang.NoClassDefFoundError: java/lang/Object"，这个类很早就应该加载过了，为何会抛异常找不到该类呢
	    * 由此说明：1、加载子类会先检查父类是否加载；
	    *           2、类的唯一性是由类加载器和类本身共同决定的，同一个类只要加载器不同，就是不同的两个类
	    */
//	   if (clazz == null) {
//		   clazz = findClass(name);
//	   }
	   return clazz;
	}
	
	//将.class文件读取为字节流
	private byte[] getClassBytes(File file) throws Exception {
		FileInputStream fileInputStream = new FileInputStream(file);
		FileChannel fileChannel = fileInputStream.getChannel();
		ByteArrayOutputStream baosArrayOutputStream = new ByteArrayOutputStream();
		WritableByteChannel writableByteChannel = Channels.newChannel(baosArrayOutputStream);
		ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
		
		int i;
		while (true) {
			i = fileChannel.read(byteBuffer);
			if (i==0 || i==-1) {
				break;
			}
			byteBuffer.flip();
			writableByteChannel.write(byteBuffer);
			byteBuffer.clear();
		}
		fileInputStream.close();
		return baosArrayOutputStream.toByteArray();
	}
}

public class Main {
    public static void main(String args[]) throws Exception {
        MyClassLoader classLoader = new MyClassLoader("F:/");
        Class<?> clazz = classLoader.loadClass("ClassLoader.MyClass");//带上包名
        		
        Object obj = clazz.newInstance();
        System.out.println(obj);  
    }
}