多线程

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 Demo1_2 {

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

class MyRunable implements Runnable {
    
    @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 Demo1_1 {

    public static void main(String[] args) {  
        Runnable demo = new MyRunable();     // 新建“Runnable对象”
        //2个线程处理同一个任务
        Thread t1 = new Thread(demo, "t1");  // 新建“线程t1”, t1是基于demo这个Runnable对象
        Thread t2 = new Thread(demo, "t2");  // 新建“线程t2”, t2是基于demo这个Runnable对象
        t1.start();                          // 启动“线程t1”
        t2.start();                          // 启动“线程t2” 
    } 
}

class Count {

    // 含有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 Demo2 {

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

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


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

pulbic class Something {
    public synchronized void isSyncA(){}
    public synchronized void isSyncB(){}
    public static synchronized void cSyncA(){}
    public static synchronized void cSyncB(){}
}

在Object.java中，定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。

Object类中关于等待/唤醒的API详细信息如下：
notify()                        -- 唤醒在此对象监视器上等待的单个线程。
notifyAll()                     -- 唤醒在此对象监视器上等待的所有线程。
wait()                          -- 让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)。
wait(long timeout)              -- 让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。
wait(long timeout, int nanos)   -- 让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量”，当前线程被唤醒(进入“就绪状态”)。

package com.test;
// WaitTest.java的源码
class ThreadA extends Thread{

    public ThreadA(String name) {
        super(name);
    }

    public void run() {
        System.out.println("1111");
        synchronized (this) {
            System.out.println(Thread.currentThread().getName()+" call notify()");
            // 唤醒当前的wait线程
            notify();
            System.out.println("2222");
        }
    }
}

public class WaitTest {

    public static void main(String[] args) {

        ThreadA t1 = new ThreadA("t1");

        synchronized(t1) {
            try {
                System.out.println(Thread.currentThread().getName()+" start t1");
                t1.start();  //main线程和新线程用的是同一个锁t1，start方法调用后，run方法不能进去，因为锁被main线程占用。

                System.out.println(Thread.currentThread().getName()+" wait()");
                t1.wait();  //锁调用wait方法，让正在使用锁t1的main线程等待，wait方法让当前线程释放锁，run方法进去，notify()唤醒等待的main线程，synchronized执行完之后释放锁，main才可以继续走下去。

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

/*
 t1.wait()应该是让“线程t1”等待；但是，为什么却是让“主线程main”等待了呢？
 注意：jdk的解释中，说wait()的作用是让“当前线程”等待，而“当前线程”是指正在cpu上运行的线程！
这也意味着，虽然t1.wait()是通过“线程t1”调用的wait()方法，但是调用t1.wait()的地方是在“主线程main”中。而主线程必须是“当前线程”，也就是运行状态，才可以执行t1.wait()。
所以，此时的“当前线程”是“主线程main”！因此，t1.wait()是让“主线程”等待，而不是“线程t1”！
 */

package com.test;
public class WaitNotifyDemo1 {
    private int num; //输出数字
    private int runThreadNum; //当前运行线程编号
     
    public WaitNotifyDemo1(int num, int runThreadNum){
        this.num = num;
        this.runThreadNum = runThreadNum;
    }
     
     
    /**
     * 打印线程
     */
    static class PrintThread extends Thread{
        private int threadNum; //当前运行线程编号
        private WaitNotifyDemo1 demo; //锁对象
         
        public PrintThread(int threadNum, WaitNotifyDemo1 demo){
            this.threadNum = threadNum;
            this.demo = demo;
        }
         
        @Override
        public void run() {
            synchronized (demo) {
                try{
                    for(int i=1; i<=5; i++){
                        while(true){
                            if(threadNum == demo.runThreadNum){
                                break;
                            }
                            else{
                                //如果当前线程不是接下来要运行的线程，进入等待池
                                demo.wait(); 
                            }
                        }
                         
                        for(int j=1; j<=5; j++){
                            System.out.println("线程"+threadNum+"："+(++demo.num));
                        }
                         
                        demo.runThreadNum = demo.runThreadNum%3 +1; //计算之后运行的线程编号
                        demo.notifyAll(); //唤醒所有等待池中的线程
                    }
                }
                catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
     
     
    public static void main(String[] args) {
        WaitNotifyDemo1 demo = new WaitNotifyDemo1(0,1);
         
        new PrintThread(1,demo).start();
        new PrintThread(2,demo).start();
        new PrintThread(3,demo).start();
    }
}

public class Print {
 
//3个线程处理同一个任务，

    public static void main(String[] args) {
        new Thread(new PrintRunnable(1)).start();
        new Thread(new PrintRunnable(2)).start();
        new Thread(new PrintRunnable(3)).start();
    }
}
class PrintRunnable implements Runnable {
 
    private static volatile int printNum = 0;
    private int threadId;
 
    public PrintRunnable(int threadId){
        this.threadId = threadId;
    }
    @Override
    public void run() {
            while(printNum < 75){
                synchronized (Print.class){
                    if (printNum/5%3 + 1 == threadId){
                        for (int i = 0; i <5; i++) {
                            System.out.println("线程"+threadId+":"+(++printNum));
                        }
                        Print.class.notifyAll();
                    }else {
                        try {
                            Print.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
 
                }
        }
    }
}