多线程基础2-同步代码块、同步方法

实现方式同步代码块

继承方式同步代码块

Runnable同步方法

继承方式同步方法

单利模式线程安全

实现方式同步代码块

package safly;

//使用实现Runnable接口的方式，售票
/*
* 此程序存在线程的安全问题：打印车票时，会出现重票、错票
* 1.线程安全问题存在的原因？
*   由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
*
* 2.如何来解决线程的安全问题？
*   必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
*
* 3.java如何实现线程的安全：线程的同步机制
*
*      方式一：同步代码块
*      synchronized(同步监视器){
*          //需要被同步的代码块（即为操作共享数据的代码）
*      }
*      1.共享数据：多个线程共同操作的同一个数据(变量)
*      2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁
*      要求：所有的线程必须共用同一把锁！
*      注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!
*
*      方式二：同步方法
*
*
*/

class Window2 implements Runnable {
int ticket = 20;// 共享数据
//  Object obj = new Object(); 也可以
public void run() {
//      Animal a = new Animal();//局部变量不可以
while (true) {
synchronized (this) {//this表示当前对象，本题中即为w
if (ticket > 0) {

System.out.println(Thread.currentThread().getName()
+ "售票，票号为：" + ticket--);
}else{
break;
}
}
}
}
}

public class Demo {
public static void main(String[] args) {
Window2 w = new Window2();
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();
}
}
class Animal{

}

输出如下：

窗口3售票，票号为：20
窗口3售票，票号为：19
窗口3售票，票号为：18
窗口3售票，票号为：17
窗口3售票，票号为：16
窗口3售票，票号为：15
窗口3售票，票号为：14
窗口3售票，票号为：13
窗口3售票，票号为：12
窗口1售票，票号为：11
窗口1售票，票号为：10
窗口3售票，票号为：9
窗口3售票，票号为：8
窗口3售票，票号为：7
窗口2售票，票号为：6
窗口2售票，票号为：5
窗口2售票，票号为：4
窗口2售票，票号为：3
窗口2售票，票号为：2
窗口2售票，票号为：1

继承方式同步代码块

package safly;

//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题--->使用同步代码块处理。
class Window3 extends Thread {
static int ticket = 20;
static Object obj = new Object();

public void run() {
while (true) {
// synchronized (this) {//在本问题中，this表示：w1,w2,w3 不能使用
synchronized (obj) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName()
+ "售票，票号为：" + ticket--);
}else{
break;
}
}
}
}
}

public class Demo {
public static void main(String[] args) {
Window3 w1 = new Window3();
Window3 w2 = new Window3();
Window3 w3 = new Window3();

w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");

w1.start();
w2.start();
w3.start();
}
}

输出如下：

窗口1售票，票号为：20
窗口3售票，票号为：19
窗口3售票，票号为：18
窗口3售票，票号为：17
窗口2售票，票号为：16
窗口2售票，票号为：15
窗口2售票，票号为：14
窗口2售票，票号为：13
窗口2售票，票号为：12
窗口2售票，票号为：11
窗口2售票，票号为：10
窗口2售票，票号为：9
窗口2售票，票号为：8
窗口2售票，票号为：7
窗口2售票，票号为：6
窗口2售票，票号为：5
窗口2售票，票号为：4
窗口2售票，票号为：3
窗口2售票，票号为：2
窗口2售票，票号为：1

需要注意是synchronized (this) {//在本问题中，this表示：w1,w2,w3 不能使用

只能使用静态static Object obj = new Object(); 共同的一把锁

Runnable同步方法

package safly;

//使用实现Runnable接口的方式，售票
/*
* 此程序存在线程的安全问题：打印车票时，会出现重票、错票
* 1.线程安全问题存在的原因？
*   由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
*
* 2.如何来解决线程的安全问题？
*   必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
*
* 3.java如何实现线程的安全：线程的同步机制
*
*      方式一：同步代码块
*      synchronized(同步监视器){
*          //需要被同步的代码块（即为操作共享数据的代码）
*      }
*      1.共享数据：多个线程共同操作的同一个数据(变量)
*      2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁
*      要求：所有的线程必须共用同一把锁！
*      注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!
*
*      方式二：同步方法
*      将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行
*      此方法时，其它线程在外等待直至此线程执行完此方法。
*      >同步方法的锁：this
*
* 4.线程的同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。
*
*/

class Window4 implements Runnable {
int ticket = 20;// 共享数据

public void run() {
while (true) {
show();
}
}

public synchronized void show() {

if (ticket > 0) {

System.out.println(Thread.currentThread().getName() + "售票，票号为："
+ ticket--);
}

}
}

public class Demo {
public static void main(String[] args) {
Window4 w = new Window4();
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();
}
}

输出如下：

窗口3售票，票号为：20
窗口3售票，票号为：19
窗口3售票，票号为：18
窗口3售票，票号为：17
窗口3售票，票号为：16
窗口3售票，票号为：15
窗口3售票，票号为：14
窗口3售票，票号为：13
窗口3售票，票号为：12
窗口3售票，票号为：11
窗口3售票，票号为：10
窗口3售票，票号为：9
窗口3售票，票号为：8
窗口3售票，票号为：7
窗口3售票，票号为：6
窗口3售票，票号为：5
窗口3售票，票号为：4
窗口3售票，票号为：3
窗口3售票，票号为：2
窗口3售票，票号为：1

继承方式同步方法

package safly;

//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题--->使用同步代码块处理。
class Window3 extends Thread {
static int ticket = 20;

public void run() {
while (true) {
show();
}
}

public synchronized void show() {// this充当的锁
if (ticket > 0) {

System.out.println(Thread.currentThread().getName() + "售票，票号为："
+ ticket--);

}
}
}

public class Demo {
public static void main(String[] args) {
Window3 w1 = new Window3();
Window3 w2 = new Window3();
Window3 w3 = new Window3();

w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");

w1.start();
w2.start();
w3.start();

}

}

输出的代码跟上面一样~~

单利模式线程安全

package safly;

//关于懒汉式的线程安全问题：使用同步机制
//对于一般的方法内，使用同步代码块，可以考虑使用this。
//对于静态方法而言，使用当前类本身充当锁。
class Singleton {
private Singleton() {

}

private static Singleton instance = null;

public static Singleton getInstance() {

if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {

instance = new Singleton();
}
}
}
return instance;
}
}

public class Demo {

public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
// Class clazz = Singleton.class;
}
}