Java 并发——多线程基础

/***  Thread类。
*/
class MyThread extendsThread {    
    public voidrun() {
    //...  线程执行
}
}
public classTestThread1 {
    public static voidmain(String args[]) {
        MyThread thread = new MyThread ();    //新建线程。
        thread .start();                    //线程开始执行。
        //主线程其他方法
}
}

class MyRunner implements Runnable {    //实现Runnable接口
    public voidrun() {
    //......    线程执行
}
}

public classTestThread1 {
    public static voidmain(String args[]) {
        MyRunner runner= newRunner1(); 
        Thread t = new Thread(runner);    //新建线程。
        t.start();                   //线程开始执行。
        //......    主线程继续执行
}

}

public final void join() throwsInterruptedException
public final synchronized void join(long millis) throws InterruptedException

public classJoinMain {
    public volatile static int i=0; 
    public static class AddThread extendsThread{ 
        @Override 
        public voidrun() {
            for(i=0;i<10000000;i++); 
        }
    }

    public static void main(String[] args) throwsInterruptedException { 
        AddThread at=newAddThread(); 
        at.start(); 
        at.join();     //当前线程（主线程）等待at线程运行结束。
System.out.println(i); 
    } 
}

while( 指定的线程.isAlive()) {
    wait(0);
}

public classStopThreadTest {
    
    static Student stu = newStudent();
    
    public static void main(String[] args) throwsInterruptedException {
        
        Thread writeThread = newThread(){
            @Override
            public voidrun() {
                //假设writeThread比readThread先拿到stu的锁。
                synchronized(stu){
                    stu.id = 2;    //可能该语句执行完后，主线程中 writeThread.stop(); 开始产生作用。
                    //若主线程执行 writeThread.stop();则该线程在此处将强行结束。
java_label_stop:
                    stu.name = "小王";
                }
            }
        };
        
        Thread readThread = newThread(){
            @Override
            public voidrun() {
                //假设writeThread比readThread先拿到stu的锁。
                synchronized(stu){
                    //若在java_label_stop处writeThread被结束，则该语句将打印出 2 ; 小明 。从而导致数据一致性错误
                    System.out.println(stu.id + ";" +stu.name);
                }
                
            }
        };
        
        
        //主线程设置stu。
        stu.id = 1;
        stu.name = "小明";
        
        //假设writeThread比readThread先拿到stu的锁。
writeThread.start();
        readThread.start();
        
        //强制停止写线程。
writeThread.stop();
    }
    
}

classStudent{
    public intid;
    publicString name;
}

public void Thread.interrupt()               //中断线程。修改线程的中断状态，但线程本身不会有任何响应，依旧运行。

public boolean Thread.isInterrupted()        //判断是否被中断。

public static boolean Thread.interrupted()   //判断是否被中断，并清除当前中断状态

public classInterruptThreadTest {
    public static voidmain(String[] args) {
        
        Thread t1 = newThread(){
            
            @Override
                public voidrun(){ 
                    while(true){ 
                        Thread.yield(); 
                    } 
                }
        };

        t1.start();        //启动线程。
        t1.interrupt();    //终端线程，线程会依旧运行。
}
}

public classInterruptStopThreadTest {
    public static voidmain(String[] args) {
        Thread t1 = newThread() {

            @Override
            public voidrun() {
                while (true) {
                    //检测线程被中断
                    if(Thread.currentThread().isInterrupted()) {
                        //若线程中断，则推出run方法。
                        System.out.println("Interruted!");
                        break;
                    }

                    Thread.yield();
                }
            }
        };

        t1.start();     //启动线程。
        t1.interrupt(); //终端线程，但线程依旧运行。t1.isInterrupted()方法将返回true。
}
}

public classInterruptedExceptionTest {
    public static void main(String[] args) throwsInterruptedException {
        Thread t1 = newThread() {
            
            @Override
            public voidrun() {
                while (true) {
                    if(Thread.currentThread().isInterrupted()) {
                        System.out.println("Interruted!");
                        break;
                    }
                    try{
                        Thread.sleep(2000);
                    } catch(InterruptedException e) {
                        System.out.println("Interruted When Sleep");
                        //抛出异常后会清除中断标记位。所以重新设置中断状态。
Thread.currentThread().interrupt();
                    }
                    Thread.yield();
                }
            }
        };
        
        
        t1.start();
        
        //让主线程在恰当的时间去中断t1。
        Thread.sleep(1000);
        
        //此时t1处于sleep状态。interrupt() 方法会使t1中的sleep方法抛出InterruptedException异常。
t1.interrupt();

    }
}

Interruted When Sleep
Interruted!

packagesjq.thread.suspend_resume;
packagesjq.thread.suspend_resume;

public classSuspendResumeThreadTest {
    
    public static Object u = newObject();
    public static ChangeObjectThread t1 = new ChangeObjectThread("t1");
    public static ChangeObjectThread t2 = new ChangeObjectThread("t2");
    
    public static class ChangeObjectThread extendsThread {
        publicChangeObjectThread(String name){
            super.setName(name);
        }

        @Override
        public voidrun() {
            synchronized(u){
                System.out.println("in " + super.getName());
                Thread.currentThread().suspend();
            }
        }
        
    }
    
    public static void main(String[] args) throwsInterruptedException {
        t1.start();
        Thread.sleep(100);
        t2.start();
        t1.resume();  //主线程通知t1要释放resume，但t1线程可能还未执行suspend，当t1执行了suspend后，则t1将永远被挂起。且不会释放资源。
        t2.resume();  //主线程通知t2要释放resume，但t2线程可能还未执行suspend，当t2执行了suspend后，则t2将永远被挂起。且不会释放资源。
t1.join();
        t2.join();
    }
}