在多线程的处理之中，可以利用Runnable描述多个线程操作的资源，而Thread描述每一个线程对象，于是当多个线程访问同一资源的时候，如果处理不当就会产生数据的错误操作。
同步问题的引出
范例：创建若干个线程对象实现卖票操作
class MyThread implements Runnable{
private int ticket = 10;
public void run() {
while(true) {
if(this.ticket > 0) {
try {
Thread.sleep(100); // 模拟网络延迟操作
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + this.ticket--);
}
else {
System.out.println("无票");
break;
}
}
}
}
public class Main{
public static void main(String args[]) throws Exception {
MyThread mt = new MyThread();
new Thread(mt, "窗口1").start();
new Thread(mt, "窗口2").start();
new Thread(mt, "窗口3").start();
}
}
当有延迟的时候就能很轻易地看到问题所在
解决同步问题的关键是锁，指的是当某一个线程执行操作的时候，其他线程外面等待。
使用synchronized关键字可以定义同步方法或者同步代码块；在同步代码块的操作里面的代码同一时间只允许一个线程执行。
1.利用同步代码块进行处理
synchronized(同步对象){
同步代码操作;
}
一般要进行同步对象处理的时候可以采用当前对象this进行同步。
范例：利用同步代码块解决数据同步访问问题
class MyThread implements Runnable{
private int ticket = 10;
public void run() {
while(true) {
synchronized(this) { // 同步代码块
if(this.ticket > 0) {
try {
Thread.sleep(100); // 模拟网络延迟操作
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + this.ticket--);
}
else {
System.out.println("无票");
break;
}
}
}
}
}
public class Main{
public static void main(String args[]) throws Exception {
MyThread mt = new MyThread();
new Thread(mt, "窗口1").start();
new Thread(mt, "窗口2").start();
new Thread(mt, "窗口3").start();
}
}
加入同步之后，虽然不会再出现数据上出错的问题，但是程序的整体行能下降了。
2.利用同步方法解决：只需要再方法定义上使用synchronized关键字即可
class MyThread implements Runnable{
private int ticket = 10;
public synchronized boolean sale() {
if(this.ticket > 0) {
try {
Thread.sleep(100); // 模拟网络延迟操作
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + this.ticket--);
return true;
}
else {
System.out.println("无票");
return false;
}
}
@Override
public void run() {
while(true) {
if(!this.sale()) {
break;
}
}
}
}
public class Main{
public static void main(String args[]) throws Exception {
MyThread mt = new MyThread();
new Thread(mt, "窗口1").start();
new Thread(mt, "窗口2").start();
new Thread(mt, "窗口3").start();
}
}
使用同步代码块和同步方法并没有多大差别，但是再Java类库许多类上的同步处理都是用的是同步方法。
死锁
死锁是再进行多线程同步处理中有可能出现的问题。所谓的死锁指的是若干个线程彼此互相等待的状态。
范例：
package threads;
class test1{
public synchronized void func(test2 t2) {
System.out.println("我是test1,需要一个test2的对象");
t2.get();
}
public synchronized void get() {
System.out.println("我是test1,得到了一个test2的对象");
}
}
class test2{
public synchronized void func(test1 t1) {
System.out.println("我是test2, 需要一个test1的对象");
t1.get();
}
public synchronized void get() {
System.out.println("我是test2,得到了一个test1的对象");
}
}
public class DeadLock implements Runnable{
private test1 t1 = new test1();
private test2 t2 = new test2();
public DeadLock() {
new Thread(this).start(); // 新启动一个线程
t2.func(t1);
}
@Override
public void run() {
t1.func(t2);
}
public static void main(String[] args) {
new DeadLock();
}
}
造成死锁的原因是互相等待。
若干个线程访问同一资源时一定要进行同步处理，而过多的同步处理会造成死锁。
死锁是同步引起的。
