JAVA进阶知识点总结 6-线程 同步 线程状态

01.第一章：多线程_回顾实现线程的方式一：

1).定义一个线程类，继承自Thread，重写run()方法；

class MyThread extends Thread{
		public void run(){
			...
		}
	}

2).启动线程
1).创建我们定义线程类的对象；
2).调用对象的start()方法启动线程；

main(){
		MyThread t = new MyThread();
		t.start();
	//	t.run();//只是普通的方法调用
	}

02.第一章：多线程_多线程的运行原理：

03.第一章：多线程_Thread类的常用方法_构造方法：

1).构造方法：

1).Thread():无参构造方法
2).Thread(String name):使用一个线程名称构造一个线程对象
每个线程都有一个默认的线程名：Thread-索引值 通过getName()方法可以获取线程名称
3).Thread(Runnable run):使用一个Runnable的实现类构造一个线程对象； 在“创建线程的方式二”中演示
4).Thread(Runnable run,String name):使用一个Runnable和一个线程名称构造一个线程对象。

03.第一章：多线程_Thread类的常用方法_成员方法：

1).public String getName():获取线程的名称；
2).public static void sleep(long millis):让当前线程休眠指定的毫秒值；

public class MyThread extends Thread {
    @Override
    public void run() {
        for (; ; ) {
            Date date = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String str = sdf.format(date);
            System.out.println(str);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3).public static Thread currentThread():获取当前的线程对象；

public class Demo {
    public static void main(String[] args) {
        //主线程也是一个线程，是由JVM来启动的
        //主线程也有线程名
	  //Thread.currentThread()可以获取当前的线程对象，然后调用getName()就能获取线程名称
        for (int k = 0; k < 100; k++) {
            System.out.println(Thread.currentThread().getName() + " k = " + k);

        }
    }
}

04.第一章：多线程_制作线程的方式二_Runnable接口：

1).定义一个子类，实现Runnable接口，重写run()方法；
/*
注意：实现Runnable后，我们的类–不是一个线程类
后期必须要委托给一个线程类Thread去执行
*/

public class MyRun implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " i = " + i);

        }
    }
}

2).启动线程：
1).创建一个自定义Runnable子类对象；
2).创建一个Thread对象，并将自定义对象作为参数传给Thread的构造方法；
3).调用Thread的start()方法启动线程。它内部会去调用我们自定义对象内部的run()方法。
示例代码：

public class Demo {
    public static void main(String[] args) {
        MyRun myRun = new MyRun();

        Thread t1 = new Thread(myRun,"章子怡");
        Thread t2 = new Thread(myRun,"汪峰");

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

    }
}

05.第一章：多线程_两种实现方式的区别：

1).第一种：继承自Thread.由于Java单继承的限制，对于子类形成了制约。
2).第二种：实现接口Runnable。子类可以同时实现多个接口【建议使用】

06.第一章：匿名内部类的方式实现线程：

1).匿名内部类的格式：

new 父类/父接口名(){
		//子类的类体
	}

2).实现线程的方式一，使用匿名内部类的方式：
new Thread(){//Thread的子类类体}.start();
示例代码：

public static void main(String[] args) {
    //Thread t = new Thread的匿名子类对象();
    new Thread(){
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("i = " + i);
            }
        }
    }.start();

//主线程继续
for (int k = 0; k < 100; k++) {
    System.out.println("k = " + k);
    }
}

2).实现线程的方式二，使用匿名内部类的方式：
new Thread(Runnable子类对象).start();
示例代码：

new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("i = " + i);
        }
    }
}).start();

07.第一章：多线程安全性问题：

1).多线程安全性问题产生的原因：多个线程同时访问同一个变量；
2).示意图：

3).代码：
1.定义一个类，实现Runnable接口：
/*
注意：实现Runnable后，我们的类–不是一个线程类
后期必须要委托给一个线程类Thread去执行
*/

public class MyRun implements Runnable {
    int a = 100;
    @Override
    public void run() {//线程1,线程2
        for (int i = 0; i < 100; i++) {//线程1(1,2)//线程2(1,2,3)//线程1(3)
           a++;//1.将a的值100取出到运算器中；2.在运算器中计算 100 + 1 ;3.将101赋给a
        }
        System.out.println("线程执行完毕！");
    }
}

2.测试类：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyRun myRun = new MyRun();

        Thread t1 = new Thread(myRun,"章子怡");
        Thread t2 = new Thread(myRun,"汪峰");

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

        //主线程休息一秒，确保上面的两个线程执行完毕
        Thread.sleep(1000);

        //获取最终的结果
        System.out.println(myRun.a);//正常：300

    }
}

08.第二章：多线程售票模拟线程安全性问题：
1).定义Tickets类：

  public class Tickets implements Runnable {
    private int tickets = 100;
    @Override
  

  public void run() {
        //死循环
        while (true){
            //判断是否有票
            if (tickets > 0) {
                //取一张
                int t = tickets;
                try {
                    Thread.sleep(1);//目的：让效果更明显,让其它线程运行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                tickets--;

                System.out.println(Thread.currentThread().getName() + 
									" 取走一张票：" + t);
            }else{
                System.out.println("没票了！");
                break;
            }
        }
    }
}

2).定义测试类：

public class Demo {
    public static void main(String[] args) {
        //1.创建一个Tickets对象
        Tickets t = new Tickets();

        //2.创建两个线程
        Thread t1 = new Thread(t,"窗口1");
        Thread t2 = new Thread(t,"窗口2");

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

    }
}

09.第二章：同步代码块_解决多线程售票线程安全性问题：

1).格式：
synchronized(锁对象){
//同步代码
}
锁对象：可以是任何对象，但必须保证多个线程共同使用同一个锁对象。
2).示例代码：
1).修改Tickets类：

public class Tickets implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if (tickets > 0) {
                    int t = tickets;
                    try {
                        Thread.sleep(1);//目的：让效果更明显
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    tickets--;

                    System.out.println(Thread.currentThread().getName() + 
									" 取走一张票：" + t);
                }else{
                    System.out.println("没票了！");
                    break;
                }
            }//一个线程执行完毕，会自动释放锁

        }
    }
}

2).主线程类：

public class Demo {
    public static void main(String[] args) {
        //1.创建一个Tickets对象
        Tickets t = new Tickets();

        //2.创建两个线程
        Thread t1 = new Thread(t,"窗口1");
        Thread t2 = new Thread(t,"窗口2");

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

    }
}

10.第二章：同步方法_解决多线程售票线程安全性问题【常用】：

1).格式：
//同步方法，使用的锁对象是：this
public synchronized int getTicket(){
//同步代码
}
2).示例代码：
1).修改Tickets类即可：

public class Tickets implements Runnable {
    private int tickets = 100;
    @Override
    public void run() {
        while (true){
            int t = this.getTicket();
            if (t > 0) {
                System.out.println(Thread.currentThread().getName() + 
									" 取走一张票：" + t);

            }else{
                System.out.println("没票了！！");
                break;
            }
        }
    }
    //同步方法，使用的锁对象是：this
public synchronized int getTicket() {
        if (tickets > 0) {
            int t = tickets;
            try {
                Thread.sleep(1);//目的：让效果更明显
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tickets--;
            return t;
        } else {
            return 0;
        }
    }
}

11.第二章：Lock锁_解决多线程售票线程安全性问题：

1).格式：

Lock l = new 某个实现类对象();
l.lock();//加锁 
try { 
	//同步代码
} finally { 
	l.unlock(); //解锁
} 

2).示例代码：

public class Tickets implements Runnable {
    private int tickets = 100;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();//加锁
            try {
                if (tickets > 0) {
                    int t = tickets;
                    try {
                        Thread.sleep(1);//目的：让效果更明显
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    tickets--;

                    System.out.println(Thread.currentThread().getName() + " 取走一张票：" + t);
                } else {
                    System.out.println("没票了！");
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();//解锁
            }
        }
    }
}

12.第三章：线程状态：

13.第三章：线程状态_无限等待_wait方法：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();

        new Thread(){
            @Override
            public void run() {
                synchronized (obj) {
                    for (int i = 0; i < 20; i++) {
                        System.out.println("i = " + i);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if (i == 10) {
                            //让当前的线程挂起，等待被唤醒
                            try {
                                System.out.println("我开始等待...");
                                obj.wait();//会立即释放obj锁
                                System.out.println("我醒了，开始干活了....");
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }.start();
        //开启一个新线程
        new Thread(){
            @Override
            public void run() {
                //获取obj锁对象
                System.out.println("第二个线程开始执行...");
                synchronized (obj){
                    //唤醒所有在obj锁上等待线程.
                    System.out.println("第二个线程开始唤醒....");
                    obj.notifyAll();//唤醒后，
                }//唤醒后，会释放锁
            }
        }.start();
    }
}

14.第三章：线程状态_无限等待_包子铺案例：

=======================================================================
学习目标总结：
01.能够描述Java中多线程运行原理
每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈

02.能够使用继承类的方式创建多线程

class MyThread extends Thread{
	public void run(){
		//...
	}
}
main(){
	MyThread t = new MyThread();
	t.start();
	t.run();//普通的方法调用
	t.start();//抛异常
}

03.能够使用实现接口的方式创建多线程

class MyRun implements Runnable{
	public void run(){
		//...
	}
}
main(){
	MyRun myRun = new MyRun();
	Thread t = new Thread(myRun);
	t.start();
}

04.能够说出实现接口方式的好处
1).解决单继承的限制。

05.能够解释安全问题的出现的原因
1).多个线程同时访问同一个变量；

06.能够使用同步代码块解决线程安全问题
synchronized(锁对象){
//同步代码
}
07.能够使用同步方法解决线程安全问题

public synchronized void show(){
	//同步代码
}

08.能够说出线程6个状态的名称
1.新建
2.可运行
3.计时等待
4.锁阻塞
5.无限等待
6.被终止
09.能够理解等待唤醒案例

public static void main(String[] args) throws InterruptedException {
Object obj = new Object();

new Thread(){
    @Override
    public void run() {
        synchronized (obj) {
            for (int i = 0; i < 20; i++) {
                System.out.println("i = " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (i == 10) {
                    //让当前的线程挂起，等待被唤醒
                    try {
                        System.out.println("我开始等待...");
                        obj.wait();//会立即释放obj锁
                        System.out.println("我醒了，开始干活了....");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}.start();
//开启一个新线程
new Thread(){
    @Override
    public void run() {
        //获取obj锁对象
        System.out.println("第二个线程开始执行...");
        synchronized (obj){
            //唤醒所有在obj锁上等待线程.
            System.out.println("第二个线程开始唤醒....");
            obj.notifyAll();//唤醒后，
        }//唤醒后，会释放锁
    }
    }.start();
}