关于java多线程

package testSynchronized;

/**
*
*  当使用this也就是该文件中的testclass对象作为对象锁时，
*  两个线程都使用该对象锁访问该对象的同步代码块，
*  是顺序执行的，
*  也就是说当一个线程使用testclass对象对这段同步代码块上锁了以后，
*  另一个线程无法再使用testclass对象进入该同步代码块
*  理解：
*  因为该锁标记对象已经被标记为正在使用，所以只能排队
*
*/
class TestClass {
public void f(){
synchronized(this){
for(int i = 0 ; i < 1000 ; i ++){
System.out.println("i: " + i );
}
}
}
}
class ThreadTest extends Thread {
private TestClass testclass ;
public ThreadTest(TestClass testclass) {
this.testclass = testclass ;
}
@Override
public void run() {
testclass.f();
}
}
public class TestSynchroinzed {
public static void main(String[] args) {
TestClass testclass = new TestClass() ;
ThreadTest thread1 = new ThreadTest(testclass) ;
ThreadTest thread2 = new ThreadTest(testclass) ;
thread1.start();
thread2.start();
}
}

package testSynchronized;
/**
*
* 在该类中测试两个线程使用不同的锁对象，观察能不能同时访问一个同步代码块
*
* 出现的结果和TestSynchronized相反。这两个线程可以同时进入该同步代码块执行。
*
* why ???????
*
* 测试结果表明：
*     使用同一对象锁的多个线程需要排队访问
*     使用不同对象锁的多个线程可以同时访问（完全是不同的对象，不同的内存空间，当然不存在线程问题）
*
* 似乎明白了：
*  使用this作为锁标记，当一个线程使用这个锁标记锁住某些
*  （可以使用一个线程同时访问使用一个对象标记锁的多个同步代码块，
*  那么这个线程就使用该对象锁住了多个同步代码块）代码块后，
*  其他的线程准备执行这个对象的这个同步代码块时，
*  会被告知这个this对象正在被使用锁住一些同步代码，还没有被释放，所以无法使用该锁进入同步代码块。
*  只有使用该锁锁住的所有同步代码块都执行结束的后，
*  其他的线程才能够重新使用该对象作为锁标记进入同步代码块
*
*  但是如果调用的就是不同的对象方法，
*  那么就不会存在同步的问题，
*  因为完全是两个不同的方法，不同的内存空间。
*/
class TestClass1 {
public void f(){
synchronized(this){
while(true);
}
}
public void f2(){
synchronized(this){
for(int i = 0 ; i < 100 ; i ++){
System.out.println("################");
}
}
}
}
class ThreadTest1 extends Thread {
private TestClass1 testclass ;
public ThreadTest1(TestClass1 testclass) {
this.testclass = testclass ;
}
@Override
public void run() {
testclass.f();
}
}
class ThreadTest2 extends Thread {
private TestClass1 testclass ;
public ThreadTest2(TestClass1 testclass) {
this.testclass = testclass ;
}
@Override
public void run() {
testclass.f2();
}
}
public class TestSynchronized2 {
public static void main(String[] args) {
TestClass1 testclass = new TestClass1() ;
TestClass1 testclass2 = new TestClass1() ;
ThreadTest1 thread1 = new ThreadTest1(testclass) ;
ThreadTest2 thread2 = new ThreadTest2(testclass) ;
thread1.start();
thread2.start();
}
}

package test;

/**
*
* 测试同步对象使用Class对象
*
* 总结： 注：每一个对象都有且仅有一个对象锁
* 1. 当同步代码块中使用的对象是一个类的普通对象， 那么当一个线程进入该同步代码块
* （或同步方法，区别不大，只是同步方法默认使用的锁对象是this） 并获取该对象的锁后（前提是该对象的锁是空闲的）， 其他线程使用同一锁对象 （例如：
* 当两个线程使用同一对象并都调用该对象的一个同步方法时） 无法进入该同步代码块， 因为该代码块的锁对象的锁已经被先来的线程占用
* （注意，是该锁对象的锁，每一个对象都有唯一的一个锁，你能否进入同步代码块的唯一条件是你有没有获得锁对象的锁），现在的情况是，
* 一个线程已经占用了同步代码块的锁对象的锁，那么锁对象的其他非同步方法可以被其他线程访问（前提是该对象有非同步方法），
* 该锁对象的其他同步方法不能被其他线程访问。
*
* 2. 当同步代码块使用的锁对象是Class对象时(例如： TestClass.class，同步静态方法和使用Class对象的同步代码块的效果是一样的）。
* 当一个线程进入同步代码块（或者调用了静态同步方法）时，它获取了该Class对象的锁，那么其他的线程将不能访问该类的同步静态方法，
* 非同步静态方法可以正常访问 。
*/

class TestClass {
/**
* 一个线程访问f，一个线程访问staticF，理论上当第一个线程访问f时就会获得TestClass.class对象锁
* 那么另一个线程无法访问静态方法。
*/
public synchronized static void staticF() {
System.out.println("执行staticF");
}

public void f() {
synchronized (TestClass.class) {
System.out.println("调用f()方法 ");
// 使用无限循环让当前线程一直占用TestClass.class对象锁
while (true)
;
}
}

/**
* 该方法的作用是测试当一个线程获得了某个对象的锁后， 其他的线程能不能访问该对象的非同步方法或者同步代码块
*/

public void f3() {
synchronized (this) {
System.out.println("执行了f3()");
/**
* 下面是无限循环，目的是让当前线程一直占用着this这个对象的锁，
* 以查看其他线程能不能访问f4()这个非同步方法和f5()这个同步方法
*/
while (true)
;
}
}

public void f4() {
System.out.println("执行了非同步方法f4()");
}

public synchronized void f5() {
System.out.println("执行了非同步方法f5()");
}
}

class Thread1 extends Thread {
private TestClass testclass;

public Thread1(TestClass testclass) {
this.testclass = testclass;
}

@Override
public void run() {
testclass.f();
}
}

class Thread2 extends Thread {
@Override
public void run() {
TestClass.staticF();
}
}

class Thread3 extends Thread {
private TestClass testclass;

public Thread3(TestClass testclass) {
this.testclass = testclass;
}

@Override
public void run() {
testclass.f3();
}
}

class Thread4 extends Thread {
private TestClass testclass;

public Thread4(TestClass testclass) {
this.testclass = testclass;
}

@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
testclass.f4();
}
}

class Thread5 extends Thread {
private TestClass testclass;

public Thread5(TestClass testclass) {
this.testclass = testclass;
}

@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
testclass.f5();
}
}

public class Test {
public static void main(String[] args) {
TestClass testclass = new TestClass();
/*
* Thread1 thread1 = new Thread1(testclass) ; Thread2 thread2 = new
* Thread2() ; thread1.start(); thread2.start();
*/
Thread3 thread3 = new Thread3(testclass);
// Thread4 thread4 = new Thread4(testclass) ;
Thread5 thread5 = new Thread5(testclass);
thread3.start();
// thread4.start() ;
thread5.start();

}
}