62_Java_多线程2_线程生命周期_线程安全

线程的生命周期

新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建 状态

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已 具备了运行的条件，只是没分配到CPU资源

运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线 程的操作和功能

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中 止自己的执行，进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结

多线程出现了安全问题

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。

导致共享数据的错误

解决方式： 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行

线程的同步-解决线程安全问题-我们通过同步机制，来解决线程的安全问题

方式一：同步代码块

方式二：同步方法

方式三：Lock锁

方式一：同步代码块

synchronized(同步监视器){  # 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器

//需要被同步的代码

}

说明： 1.操作共享数据的代码，即为需要被同步的代码。-->不能包含代码多了，也不能包含代码少了。

2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。

3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

class Window1 implements Runnable{ private int ticket = 100; @Override public void run() { while(true){ synchronized (this){ // 此时的this:唯一的Window1的对象 //方式二：synchronized (dog) { if (ticket > 0) { System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket)； ticket--; } else { break; } public class WindowTest1 { public static void main(String[] args) { Window1 w = new Window1(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); t1.start(); t2.start(); //######## 使用同步代码块解决继承Thread类的方式的线程安全问题 ############## class Window2 extends Thread{ private static int ticket = 100; @Override public void run() while(true){ synchronized (Window2.class){//Class clazz = Window2.class,Window2.class只会加载一次 if(ticket > 0){ System.out.println(getName() + "：卖票，票号为：" + ticket); ticket--; }else{ break; public class WindowTest2 { public static void main(String[] args) { Window2 t1 = new Window2(); Window2 t2 = new Window2(); Window2 t3 = new Window2(); t1.start(); t2.start(); t3.start();

方式二：同步方法。

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。

2. 非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身

//使用同步方法解决实现Runnable接口的线程安全问题 class Window3 implements Runnable { private int ticket = 100; @Override public void run() { while (true) { show(); private synchronized void show(){//同步监视器：this if (ticket > 0) { System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket); ticket--; } //使用同步方法处理继承Thread类的方式中的线程安全问题 class Window4 extends Thread { private static int ticket = 100; @Override public void run() { while (true) { show(); private static synchronized void show(){// staic静态的，意味着同步监视器：Window4.class if (ticket > 0) { System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--;

class Window4 extends Thread { private static int ticket = 100; @Override public void run() { while (true) { show(); } } private static synchronized void show(){//同步监视器：Window4.class //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的 if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; } } } public class WindowTest4 { public static void main(String[] args) { Window4 t1 = new Window4(); Window4 t2 = new Window4(); Window4 t3 = new Window4(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } }

方式三：Lock锁  --- JDK5.0新增

1. synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

2.优先使用顺序：

Lock  同步代码块（已经进入了方法体，分配了相应资源）

同步方法（在方法体之外）

class Window implements Runnable{ private int ticket = 100; //1.实例化ReentrantLock private ReentrantLock lock = new ReentrantLock(); @Override public void run() { while(true){ try{ //2.调用锁定方法lock() lock.lock(); if(ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket); ticket--; }else{ break; } }finally { //3.调用解锁方法：unlock() lock.unlock(); } } } } public class LockTest { public static void main(String[] args) { Window w = new Window(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } }

线程通信：使用两个线程打印 1-100。线程1, 线程2 交替打印

涉及到的三个方法：

wait():一旦执行此方法，  当前线程就进入阻塞状态，并释放同步监视器。

notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。

notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

说明：

1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。

2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常

3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

面试题：sleep() 和 wait()的异同？

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()

2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中

3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

class Number implements Runnable{ private int number = 1; private Object obj = new Object(); @Override public void run() { while(true){ synchronized (obj) { obj.notify(); if(number <= 100){ try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":" + number); number++; try { //使得调用如下wait()方法的线程进入阻塞状态 obj.wait(); } catch (InterruptedException e) { e.printStackTrace(); } }else{ break; } } } } } public class CommunicationTest { public static void main(String[] args) { Number number = new Number(); Thread t1 = new Thread(number); Thread t2 = new Thread(number); t1.setName("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } }

Java

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。