线程第三天：线程锁介绍

线程的优先级

使用方法setPriority()来设置线程优先级，参数是int类型，范围是1-10数字越大优先级越高。

加入线程和等待线程

• 加入线程

线程使用加入线程后就先抢占资源执行完毕后其他线程才能执行,使用join()方法来实现

加入线程的时候，必须把要先执行的线程放在最前面，然后是加入线程的代码.

• 加入线程实例代码

public class PrioThread extends Thread{
    private Object obj=new Object();
    public PrioThread(String name) {
        super(name);
    }

    public static void main(String[] args){
        PrioThread thread = new PrioThread("线程一");
        PrioThread thread1 = new PrioThread("线程二");
        PrioThread thread2 = new PrioThread("线程三");
        thread1.start();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.start();
        thread2.start();
    }
    @Override
    public void run() {
            for (int i=0; i < 50; i++) {
                System.out.println(Thread.currentThread().getName() + "正在运行" + i);
        }
    }
}

等待线程

等待线程：当前的线程从运行阶段回到就绪阶段，目的是把CPU的资源让给其他的线程。使用方法yield()方法来实现。

使用等待线程可以让线程之间的执行更加和谐

• 实例代码

public class PrioThread extends Thread{
    private Object obj=new Object();
    public PrioThread(String name) {
        super(name);
    }

    public static void main(String[] args){
        PrioThread thread = new PrioThread("线程1");
        PrioThread thread1 = new PrioThread("线程2");
        thread1.start();
        thread.start();
    }
    @Override
    public void run() {
            for (int i=0; i < 50; i++) {
                System.out.println(Thread.currentThread().getName() + "正在运行" + i);
                //当前的线程回到就绪的状态，让出CPU
                Thread.yield();
        }
    }
}

守护线程

守护线程会随着主线程的结束而结束，一旦把一个线程设置成守护线程，那么守护线程一定会随着主线程的结束而结束

• 守护线程实例代码

public class PrioThread extends Thread{
    private Object obj=new Object();
    public PrioThread(String name) {
        super(name);
    }

    public static void main(String[] args){
        PrioThread thread = new PrioThread("线程1");
        PrioThread thread1 = new PrioThread("线程2");
        thread.setDaemon(true);
        thread1.setDaemon(true);
        thread1.start();
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "主线程" + i + "正在运行");
        }
    }
    @Override
    public void run() {
            for (int i=0; i < 50; i++) {
                System.out.println(Thread.currentThread().getName() + "正在运行" + i);
                //当前的线程回到就绪的状态，让出CPU
                Thread.yield();
        }
    }
}

线程死锁

• 线程死锁代码实例
• 锁代码

public class Lock {
   static Object lock1=new Object();
   static Object lock2=new Object();
}

• 死锁线程

public class DieLockThread implements Runnable{
    boolean flag;

    public DieLockThread(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            synchronized (Lock.lock1) {
                System.out.println("线程1执行拿到锁一");
                synchronized (Lock.lock2) {
                    System.out.println("线程1执行拿到锁二");
                }
            }
        } else {
            synchronized (Lock.lock2) {
                System.out.println("线程2执行拿到锁二");
                synchronized (Lock.lock1) {
                    System.out.println("线程2执行拿到锁一");
                }
            }
        }
    }
}

• 测试代码

public class TestLock {
    public static void main(String[] args) {
        DieLockThread dieLockThread = new DieLockThread(true);
        DieLockThread dieLockThread1 = new DieLockThread(false);
        Thread thread = new Thread(dieLockThread);
        Thread thread1 = new Thread(dieLockThread1);
        thread.start();
        thread1.start();
    }
}

悲观锁和乐观锁

悲观锁：一上来就加锁，没有安全感，每次只有一个线程进入访问，完毕后再解锁。线程安全，性能较差
乐观锁：一开始不上锁，以为是没有问题的，等要出现线程安全的时候才开始控制，线程安全，性能较好

需求：一个变量，100个线程，每个线程对其加100次

• 任务类

public class MyRunable implements Runnable{
    private int count;

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for (int i = 1; i <= 100; i++) {
            System.out.println(name+"count===>"+ (++count));
        }
    }
}

• 测试类

public class ThreadTest {
    public static void main(String[] args) {
        MyRunable myRunable = new MyRunable();

        for (int i = 1; i <= 100; i++) {
            new Thread(myRunable).start();
        }
    }
}

以上代码存在线程安全问题

• 悲观锁解决
  加synchronized

public class MyRunable implements Runnable{
    private int count;

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for (int i = 1; i <= 100; i++) {
            synchronized (this){
                System.out.println(name+"count===>"+ (++count));   
            }
        }
    }
}

• 乐观锁解决
  乐观锁的算法是CAS算法

public class MyRunable implements Runnable{

    //整数修改的原子类
    private AtomicInteger count =new AtomicInteger();

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for (int i = 1; i <= 100; i++) {
            System.out.println(name+"count===>"+ count.incrementAndGet());
        }
    }
}