当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题，但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。
1 同一个资源问题
1、局部变量不能共享
public class SaleTicketDemo1 {
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
public void run(){
int total = 100;
while(total>0) {
System.out.println(getName() + "卖出一张票，剩余:" + --total);
}
}
}2、不同对象的实例变量不共享
public class SaleTicketDemo2 {
public static void main(String[] args) {
TicketSaleThread t1 = new TicketSaleThread();
TicketSaleThread t2 = new TicketSaleThread();
TicketSaleThread t3 = new TicketSaleThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleThread extends Thread{
private int total = 10;
public void run(){
while(total>0) {
System.out.println(getName() + "卖出一张票，剩余:" + --total);
}
}
}
3、静态变量是共享的共享
public class SaleTicketDemo3 {
public static void main(String[] args) {
TicketThread t1 = new TicketThread();
TicketThread t2 = new TicketThread();
TicketThread t3 = new TicketThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketThread extends Thread{
private static int total = 10;
public void run(){
while(total>0) {
try {
Thread.sleep(10);//加入这个，使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "卖出一张票，剩余:" + --total);
}
}
}共享，但是有线程安全问题
4 同一个对象的实例变量共享
public class SaleTicketDemo3 {
public static void main(String[] args) {
TicketSaleRunnable tr = new TicketSaleRunnable();
Thread t1 = new Thread(tr,"窗口一");
Thread t2 = new Thread(tr,"窗口一");
Thread t3 = new Thread(tr,"窗口一");
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleRunnable implements Runnable{
private int total = 10;
public void run(){
while(total>0) {
try {
Thread.sleep(10);//加入这个，使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
}
}
}但是存在0票和-1票情况
2 尝试解决线程安全问题
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized)来解决。
为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。注意:在任何时候,最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。
同步方法：synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。
public synchronized void method(){
可能会产生线程安全问题的代码
}同步代码块：synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。 格式:
3 锁对象选择
同步锁对象：
-
锁对象可以是任意类型。
-
多个线程对象 要使用同一把锁。
1 同步方法的锁对象问题
（1）静态方法：当前类的Class对象
（2）非静态方法：this
public class SaleTicketSafeDemo1 {
public static void main(String[] args) {
// 2、创建资源对象
Ticket ticket = new Ticket();
// 3、启动多个线程操作资源类的对象
Thread t1 = new Thread("窗口一") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个，使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
Thread t2 = new Thread("窗口二") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个，使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
Thread t3 = new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个，使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
}, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
// 1、编写资源类
class Ticket {
private int total = 10;
//非静态方法隐含的锁对象就是this
public synchronized void sale() {
if (total > 0) {
System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
} else {
throw new RuntimeException(Thread.currentThread().getName() + "发现没有票了");
}
}
public int getTotal() {
return total;
}
}
2、同步代码块的锁对象
同步锁对象：
-
锁对象可以是任意类型。
-
多个线程对象 要使用同一把锁。
-
习惯上先考虑this，但是要注意是否同一个this
public class SaleTicketSafeDemo1 { public static void main(String[] args) { // 2、创建资源对象 Ticket ticket = new Ticket(); // 3、启动多个线程操作资源类的对象 Thread t1 = new Thread("窗口一") { public void run() { while (true) { try { Thread.sleep(10);// 加入这个，使得问题暴露的更明显 ticket.sale(); } catch (Exception e) { e.printStackTrace(); break; } } } }; Thread t2 = new Thread("窗口二") { public void run() { while (true) { try { Thread.sleep(10);// 加入这个，使得问题暴露的更明显 ticket.sale(); } catch (Exception e) { e.printStackTrace(); break; } } } }; Thread t3 = new Thread(new Runnable() { public void run() { while (true) { try { Thread.sleep(10);// 加入这个，使得问题暴露的更明显 ticket.sale(); } catch (Exception e) { e.printStackTrace(); break; } } } }, "窗口三"); t1.start(); t2.start(); t3.start(); } } // 1、编写资源类 class Ticket { private int total = 10; public void sale() { synchronized (this) { if (total > 0) { System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total); } else { throw new RuntimeException(Thread.currentThread().getName() + "发现没有票了"); } } } public int getTotal() { return total; } }4 锁的范围问题
锁的范围太小：不能解决安全问题
锁的范围太大：因为一旦某个线程抢到锁，其他线程就只能等待，所以范围太大，效率会降低，不能合理利用CPU资源。
-
锁范围太小示例
public class SaleTicketSafeDemo2 { public static void main(String[] args) { TicketRunnable tr = new TicketRunnable(); Thread t1 = new Thread(tr,"窗口一"); Thread t2 = new Thread(tr,"窗口二"); Thread t3 = new Thread(tr,"窗口三"); t1.start(); t2.start(); t3.start(); } } class TicketRunnable implements Runnable { private int ticket = 10; @Override public void run() { while(ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (this) { //if (ticket > 0) {//条件没有锁进去 System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--); //} } } } }锁范围太大示例
public class SaleTicketSafeDemo3 { public static void main(String[] args) { TicketRunnableDemo tr = new TicketRunnableDemo(); Thread t1 = new Thread(tr,"窗口一"); Thread t2 = new Thread(tr,"窗口二"); Thread t3 = new Thread(tr,"窗口三"); t1.start(); t2.start(); t3.start(); } } class TicketRunnableDemo implements Runnable { private int ticket = 10; @Override public synchronized void run() { while(ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--); } } }
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
