线程高级

最新推荐文章于 2021-02-04 09:30:57 发布

加班是不可能的不加班是绝对不可能的

最新推荐文章于 2021-02-04 09:30:57 发布

阅读量195

点赞数

分类专栏：线程文章标签：线程

本文链接：https://blog.csdn.net/nihaozhanghua/article/details/78232320

版权

线程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

public class Demo1_Notify {

/**
 * @param args
 * 等待唤醒机制
 */
public static void main(String[] args) {
    final Printer p = new Printer();

    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print1();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();

    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print2();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();
}

}

//等待唤醒机制
class Printer {
private int flag = 1;
public void print1() throws InterruptedException {
synchronized(this) {
if(flag != 1) {
this.wait(); //当前线程等待
}
System.out.print(“1”);
System.out.print(“2”);
System.out.print(“3”);
System.out.print(“4”);
System.out.print(“5”);
System.out.print(“\r\n”);
flag = 2;
this.notify(); //随机唤醒单个等待的线程
}
}

public void print2() throws InterruptedException {
    synchronized(this) {
        if(flag != 2) {
            this.wait();
        }
        System.out.print("A");
        System.out.print("B");
        System.out.print("C");
        System.out.print("D");
        System.out.print("\r\n");
        flag = 1;
        this.notify();
    }
}

}

public class Demo2_NotifyAll {

/**
 * @param args
 */
public static void main(String[] args) {
    final Printer2 p = new Printer2();
    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print1();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();

    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print2();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();

    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print3();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();
}

}
/*1,在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法
* 2,为什么wait方法和notify方法定义在Object这类中?
* 因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中
* 3,sleep方法和wait方法的区别?
* a,sleep方法必须传入参数,参数就是时间,时间到了自动醒来
* wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
* b,sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡
* wait方法在同步函数或者同步代码块中,释放锁
*/
class Printer2 {
private int flag = 1;
public void print1() throws InterruptedException {
synchronized(this) {
while(flag != 1) {
this.wait(); //当前线程等待
}
System.out.print(“1”);
System.out.print(“2”);
System.out.print(“3”);
System.out.print(“4”);
System.out.print(“5”);
System.out.print(“\r\n”);
flag = 2;
//this.notify(); //随机唤醒单个等待的线程
this.notifyAll();
}
}

public void print2() throws InterruptedException {
    synchronized(this) {
        while(flag != 2) {
            this.wait();                    //线程2在此等待
        }
        System.out.print("A");
        System.out.print("B");
        System.out.print("C");
        System.out.print("D");
        System.out.print("\r\n");
        flag = 3;
        //this.notify();
        this.notifyAll();
    }
}

public void print3() throws InterruptedException {
    synchronized(this) {
        while(flag != 3) {
            this.wait();                        //线程3在此等待,if语句是在哪里等待,就在哪里起来
                                                //while循环是循环判断,每次都会判断标记
        }
        System.out.print("a");
        System.out.print("b");
        System.out.print("c");
        System.out.print("d");
        System.out.print("e");
        System.out.print("f");
        System.out.print("m");
        System.out.print("\r\n");
        flag = 1;
        //this.notify();
        this.notifyAll();
    }
}

}

public class Demo3_ReentrantLock {

/**
 * @param args
 */
public static void main(String[] args) {
    final Printer3 p = new Printer3();

    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print1();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();

    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print2();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();

    new Thread() {
        public void run() {
            while(true) {
                try {
                    p.print3();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
        }
    }.start();
}

}

class Printer3 {
private ReentrantLock r = new ReentrantLock();
private Condition c1 = r.newCondition();
private Condition c2 = r.newCondition();
private Condition c3 = r.newCondition();

private int flag = 1;
public void print1() throws InterruptedException {                          
    r.lock();                               //获取锁
        if(flag != 1) {
            c1.await();
        }
        System.out.print("1");
        System.out.print("2");
        System.out.print("3");
        System.out.print("4");
        System.out.print("5");
        System.out.print("\r\n");
        flag = 2;
        //this.notify();                        //随机唤醒单个等待的线程
        c2.signal();
    r.unlock();                             //释放锁
}

public void print2() throws InterruptedException {
    r.lock();
        if(flag != 2) {
            c2.await();
        }
        System.out.print("A");
        System.out.print("B");
        System.out.print("C");
        System.out.print("D");
        System.out.print("\r\n");
        flag = 3;
        //this.notify();
        c3.signal();
    r.unlock();
}

public void print3() throws InterruptedException {
    r.lock();
        if(flag != 3) {
            c3.await();
        }
        System.out.print("a");
        System.out.print("b");
        System.out.print("c");
        System.out.print("d");
        System.out.print("e");
        System.out.print("f");
        System.out.print("m");
        System.out.print("\r\n");
        flag = 1;
        c1.signal();
    r.unlock();
}

}

public class Demo4_ThreadGroup {

/**
 * @param args
 * ThreadGroup
 */
public static void main(String[] args) {
    //demo1();
    ThreadGroup tg = new ThreadGroup("我是一个新的线程组");      //创建新的线程组
    MyRunnable mr = new MyRunnable();                       //创建Runnable的子类对象

    Thread t1 = new Thread(tg, mr, "张三");                   //将线程t1放在组中
    Thread t2 = new Thread(tg, mr, "李四");                   //将线程t2放在组中

    System.out.println(t1.getThreadGroup().getName());      //获取组名
    System.out.println(t2.getThreadGroup().getName());

    tg.setDaemon(true);
}

public static void demo1() {
    MyRunnable mr = new MyRunnable();
    Thread t1 = new Thread(mr, "张三");
    Thread t2 = new Thread(mr, "李四");

    ThreadGroup tg1 = t1.getThreadGroup();
    ThreadGroup tg2 = t2.getThreadGroup();

    System.out.println(tg1.getName());              //默认的是主线程
    System.out.println(tg2.getName());
}

}

class MyRunnable implements Runnable {

@Override
public void run() {
    for(int i = 0; i < 1000; i++) {
        System.out.println(Thread.currentThread().getName() + "...." + i);
    }
}

}

public class Demo5_Executors {

/**
 * public static ExecutorService newFixedThreadPool(int nThreads)
 * public static ExecutorService newSingleThreadExecutor()
 */
public static void main(String[] args) {
    ExecutorService pool = Executors.newFixedThreadPool(2);//创建线程池
    pool.submit(new MyRunnable());              //将线程放进池子里并执行
    pool.submit(new MyRunnable());

    pool.shutdown();                            //关闭线程池
}

}

public class Demo6_Callable {

/**
 * @param args
 * @throws ExecutionException 
 * @throws InterruptedException 
 */
public static void main(String[] args) throws InterruptedException, ExecutionException {
    ExecutorService pool = Executors.newFixedThreadPool(2);//创建线程池
    Future<Integer> f1 = pool.submit(new MyCallable(100));              //将线程放进池子里并执行
    Future<Integer> f2 = pool.submit(new MyCallable(50));

    System.out.println(f1.get());
    System.out.println(f2.get());

    pool.shutdown();                            //关闭线程池
}

}

class MyCallable implements Callable {
private int num;
public MyCallable(int num) {
this.num = num;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for(int i = 1; i <= num; i++) {
sum += i;
}

    return sum;
}

}

加班是不可能的不加班是绝对不可能的

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程高级

public class Demo1_Notify {/** * @param args * 等待唤醒机制 */public static void main(String[] args) { final Printer p = new Printer(); new Thread() { public void run() { while
复制链接

扫一扫

专栏目录