2020/4/23学习笔记day46

java-day46

死锁

线程t1拿着t2线程需要的锁不释放，线程t2拿着t1线程需要的锁不释放。

//例如：
public class ThreadTest3 {

    public static void main(String[] args) {


        Thread t1 = new ThreadDeadLock("t1");
        Thread t2 = new ThreadDeadLock("t2");

        t1.start();
        t2.start();

    }


    private static class ThreadDeadLock extends Thread{
        private static Object obj1 = new Object();
        private static Object obj2 = new Object();

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

        @Override
        public void run() {
            String name = Thread.currentThread().getName();
            if("t1".equals(name)) {
                while(true) {
                    synchronized (obj1) {
                        synchronized (obj2) {
                            System.out.println(name+": 正在运行...");
                        }
                    }
                }
            }
            else if("t2".equals(name)) {
                while(true) {
                    synchronized (obj2) {
                        synchronized (obj1) {
                            System.out.println(name+": 正在运行...");
                        }
                    }
                }
            }

        }

    }

}

线程让步

public static native void yield();

当一个就绪状态的线程，抢到cpu执行权之后，进入到了运行状态，在运行期间，如果调用了yield()方法，这个线程就让步，交出cpu的执行权，回到就绪状态，相当于这个线程把这一次本来应该是它来使用cpu运行代码的机会，给让出去了。

注意，一个线程拿着锁对象之后，调用了yield方法， 只会交出cpu执行权，从运行状态回到就绪状态，但是不会释放锁的。想要释放锁，需要把加锁的代码执行完，或者调用了wait方法。

public class ThreadTest5 {

    public static void main(String[] args) {

        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                for(int i=0;i<100;i++) {
                    System.out.println("t1: i="+i);
                    Thread.yield();
                }
                System.out.println("t1线程运行结束");
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                for(int j=0;j<100;j++) {
                    System.out.println("t2: j="+j);

                }
                System.out.println("t2线程运行结束");
            }
        };


        t1.start();
        t2.start();

    }

}

线程优先级

优先级高的线程，在和其他线程争夺cpu时间片的使用权的时候，会有更高的概率来获取这次cpu的使用权，但是只是概论高些，并不是百分百。最终这种优先级能对线程获取CPU的使用权的概率有多少提升，这个能看操作系统对cpu调度算法的具体实现来确定。
一个线程t1被创建出来之后，如果没有设置优先级的话，那么它的默认优先级会和父线程保持一致。

例如，在main线程中 调用了Thread类的构造器，创建了t1线程，那么main线程就是t1线程的父线程，t1的优先级就默认和main线程的保持一致。
注意，main线程的优先级是5，这是JVM创建main线程的时候设置好的。优先级最小是1，最大是10.

//Thread类中声明了三个静态常量，来表示常用的优先级。
public class Thread{

    public final static int MIN_PRIORITY = 1;
    public final static int NORM_PRIORITY = 5;
    public final static int MAX_PRIORITY = 10;

    设置线程优先级的方法
        public final void setPriority(int newPriority)
        获取设置线程优先级的方法
        public final int getPriority()
}

注意，如果要改变线程的优先级，一定要在线程启动之前进行设置。

public class ThreadTest6 {

    //main线程
    public static void main(String[] args) {

        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                for(int i=0;i<1000;i++) {
                    System.out.println("t1: i="+i);
                    //Thread.yield();
                }
                System.out.println("t1线程运行结束");
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                for(int j=0;j<1000;j++) {
                    System.out.println("t2: j="+j);
                }
                System.out.println("t2线程运行结束");
            }
        };

        //System.out.println(t1.getPriority());
        //System.out.println(t2.getPriority());

        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);

        t1.start();
        t2.start();
    }

}

自建工具类实现线程安全

package com.zzb.day46;

import java.util.ArrayList;
import java.util.List;

public class ThreadTest10 {
	
	public static void main(String[] args) {
		
		//NumPrintTest是非线程安全的
		Printable p = new NumPrintTest();
		
		//通过这个工具类的方法后，可以返回一个线程安全的实现
		p = MyUtils.synchronizedNumPrint(p);
		
	}
	
	
	private static interface Printable{
		public void printNum();
		public void addNum(int i);
	}
	
	private static class NumPrintTest implements Printable{
		
		private List<Integer> list = new ArrayList<>();
		
		@Override
		public void printNum() {
			for(Integer i:list) {
				System.out.println(i.intValue());
			}
		}

		@Override
		public void addNum(int i) {
			list.add(i);
		}
		
	}
	
	private static class MyUtils{
		public static Printable synchronizedNumPrint(Printable p) {
			return new SynchronizedNumPrintImpl(p);
		}
	}
	
	private static class SynchronizedNumPrintImpl implements Printable{
		private Printable p;
		public SynchronizedNumPrintImpl(Printable p) {
			this.p = p;
		}
		@Override
		public void printNum() {
			synchronized (p) {
				p.printNum();
			}
		}
		@Override
		public void addNum(int i) {
			synchronized (p) {
				p.addNum(i);
			}
		}		
	}
}