并发与多线程

1、创建线程：

/*
 * 创建线程：
 * 方法一：（1）创建类Thread1继承Thread类，重写run()方法
 * （2）在main线程中创建Thread1对象，并用start
 * */
public class Thread1 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("i is :"+i+" "+Thread.currentThread().getName());
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        //创建线程第一种方法：
        for(int i=0;i<5;i++){
            Thread1 thread1=new Thread1();
            thread1.start();
        }
    }
}

/*第二种方法：（1）创建Thread2实现Runnable接口，并实现run()方法
              （2）在主线程main中创建线程,创建Thread对象Thread thread=new Thread(new Thread2()); 调用启动方法start()
* */
public class Thread2 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("i is :"+" "+Thread.currentThread().getName());
        }
    }
}

//创建线程第二种方法：
        for (int i=0;i<5;i++){
            Thread thread=new Thread(new Thread2());
            thread.start();
        }

        //创建线程第三种方法：创建Runnable内部类
        Thread thread = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName());
                    }
                }
        );
        thread.start();

2、实现同步

public class ThreadNum extends Thread {
    private static int num = 50;

    //没有使用同步
    @Override
    public void run() {
        while (num > 0) {
            try{
                sleep(10l);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("num is " + num + " " + Thread.currentThread().getName());
            num--;
        }
    }
}

结果：

num is 50 Thread-1
.......
num is 1 Thread-4
num is 0 Thread-1
num is -1 Thread-3
num is -2 Thread-2
num is -3 Thread-0

由于没有实现同步，出现了num为负数的情况。

/*     * 发现出现负数的情况，说明两个以上线程进入了while(num>0)中，所以要实现同步。
     * 方法1：使用同步代码块
     * 语法：synchronized(同步锁){
     *          //需要同步操作的代码
     *       }
     *       同步锁又叫同步监听对象、同步监听器、互斥锁；
     *       任何时候只有一个线程能拿到同步锁；
     *       同步锁可以是相对于线程不变化的对象，一般情况下把当前并发访问的共同资源作为同步监听对象。
     *
     * 方法2：使用同步方法
     *
     * 方法3：使用锁机制
     * */


//方法1：使用同步代码块
    @Override
    public void run() {
        //这里使用当前对象的字节码文件作为同步锁
        for (int i = 0; i < 50; i++) {
            synchronized (this.getClass()) {
                if (num > 0) {
                    try {
                        Thread.sleep(10l);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("num is " + num + " " + Thread.currentThread().getName());
                    num--;
                }
            }
        }
    }

    //方法2：使用同步方法
    @Override
    public void run() {
        for(int i=0;i<50;i++){
            numDown();
        }
    }

    private synchronized void numDown() {
        while (num > 0) {
            try {
                Thread.sleep(10l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("num is " + num + " " + Thread.currentThread().getName());
            --num;
        }
    }

/**
 * 使用锁的方式实现同步
 */
public class NumRunnable implements Runnable{
    private static int num=50;

    //创建一个锁
    Lock lock=new ReentrantLock();
    @Override
    public void run(){
        for(int i=0;i<50;i++){
            // 获取锁
            lock.lock();
            try{
                if(num>0){
                    Thread.sleep(10l);
                    System.out.println("num is "+num+","+Thread.currentThread().getName());
                    num--;
                }
                Thread.sleep(10l);
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }
}

3、生产者和消费者

public class Person {
    private String name;
    private int age;

    private boolean isEmpty = true;//实例变量（单例模式下是非线程安全的），资源对象是否为空，为空则为true，表示需要生产。如果为false，则不需要生产

    public synchronized void push(String name, int age) {
        try {
            while (!isEmpty) {//如果不是空的（消费者还未消费）
                this.wait();
            }
            //-----生产数据开始----
            this.name = name;
            Thread.sleep(10l);
            this.age = age;
            //-----生产数据结束----
            isEmpty = false;//表示不是空的，需要消费者消费
            this.notifyAll();//生产完毕，唤醒所有消费者
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void pop() {
        try {
            while (isEmpty) {//如果是空的，则先需要生产者生产，才能消费
                this.wait();
            }
            //---消费数据开始----
            Thread.sleep(10l);
            System.out.println("name---" + name + "," + "age---" + age);
            //----消费数据结束----
            isEmpty = true;
            this.notifyAll();//消费完毕，唤醒所有生产者
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

生产者：

public class Producer implements Runnable {
    private Person person;

    public Producer(Person person) {
        this.person = person;
    }

    @Override
    public void run() {
        //生产对象
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                person.push("Tom", 10);
                System.out.println("i is " + i + " Tom");
            } else {
                person.push("Lily", 20);
                System.out.println("i is " + i + " Lily");
            }
        }
    }
}

消费者：

public class Consumer implements Runnable {
    private Person person;

    public Consumer(Person person) {
        this.person = person;
    }

    @Override
    public void run() {
        //消费对象
        this.person.pop();
    }
}

测试：

//生产者与消费者模式:生产者生产一次数据，就暂停生产者线程，等待消费者消费；消费者消费完了，消费者线程暂停，等待生产者生产数据
        //同步锁池：同步锁必须选择多个线程共同的资源对象，而一个线程获得锁的时候，其他线程都在同步锁池获取锁；当那个线程释放
        //同步锁后，其他线程开始由CPU调度分配锁
        Person person = new Person();//多个线程共享的资源
        for (int i = 0; i < 50; i++) {
            Thread thread = new Thread(new Producer(person));
            thread.start();
            Thread thread1 = new Thread(new Consumer(person));
            thread1.start();
        }

wait():执行该方法的线程对象，释放同步锁，JVM会把该线程放到等待池中，等待其他线程唤醒该线程

notify():执行该方法的线程唤醒在等待池中等待的任意一个线程，把线程转到锁池中等待（注意锁池和等待池的区别）

notifyAll():执行该方法的线程唤醒在等待池中等待的所有线程，把线程转到锁池中等待。

假设 A 线程和 B 线程同时操作一个 X 对象，A，B 线程可以通过 X 对象的 wait() 和 notify() 方法来进行通信，流程如下：

①、当线程 A 执行 X 对象的同步方法时，A 线程持有 X 对象的 锁，B线程在 X 对象的锁池中等待

②、A线程在同步方法中执行 X.wait() 方法时，A线程释放 X 对象的锁，进入 X 对象的等待池中

③、在 X 对象的锁池中等待锁的 B 线程获得 X 对象的锁，执行 X 的另一个同步方法

④、B 线程在同步方法中执行 X.notify() 方法，JVM 把 A 线程从等待池中移动到 X 对象的锁池中，等待获取锁

⑤、B 线程执行完同步方法，释放锁，等待获取锁的 A 线程获得锁，继续执行同步方法