java异步调用方法 锁_线程介绍，异步，对象锁

线程基础：

当创建线程时，会为非static对象各自申请内存空间

卖票程序：

线程的优先级用1-10之间的整数表示，数值越大优先级越高，默认的优先级为5。

pupublic class Main {

static int ticket = 10;

static Runnable mRunnable = new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

while (true) {

synchronized (this) {

if (ticket > 0) {

try {

Thread.sleep(1000);

System.out.println(Thread.currentThread().getName()

+ "卖出票-->" + ticket--);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

} else {

break;

}

}

}

}

};

public static void main(String[] args) {

Thread t1 = new Thread(mRunnable, "线程， A\t");

Thread t2 = new Thread(mRunnable, "线程， B\t");

t1.setPriority(1);

t2.setPriority(10);

t1.start();

t2.start();

}

}

卖票程序(两线程各自有自己的票仓库)

将ticket设为non-static

public class MyThread implements Runnable {

int ticket = 100;

@Override

public void run() {

// TODO Auto-generated method stub

while (true) {

synchronized (this) {

if (ticket > 0) {

try {

Thread.sleep(10);

System.out.println(Thread.currentThread().getName() + "卖出票-->" + ticket--);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

} else {

break;

}

}

}

}

public static void main(String[] args) {

Runnable run1 = new MyThread();

Runnable run2 = new MyThread();

Thread t1 = new Thread(run1,"线程   A\t");

Thread t2 = new Thread(run2,"线程   B\t");

t1.start();

t2.start();

try {

t1.join();

System.out.println(t1.getName() + "卖完票");

t2.join();

System.out.println(t2.getName() + "卖完票");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

public class LockDemo implements Runnable{

private static Object object1 = new Object();

private static Object object2 = new Object();

private int flag = 0;

public static void main(String[] args) throws InterruptedException {

LockDemo run0 = new LockDemo();

LockDemo run1 = new LockDemo();

run0.flag = 1;    //here

run1.flag = 2;    //

Thread thread1 = new Thread(run0);

Thread thread2 = new Thread(run1);

thread1.start();

thread2.start();

}

@Override

public void run()

{

System.out.println(flag);

if (flag == 1)

{

synchronized (object1)

{

System.out.println("线程 ： " + flag + "锁定obj1，休息0.5秒后锁定obj2去！");

try

{

Thread.sleep(500);

}

catch (Exception e)

{

e.printStackTrace();

}

synchronized (object2)

{

System.out.println("线程 : " + flag + "访问 object2");

}

}

}

if (flag == 2)

{

synchronized (object2)

{

System.out.println("线程 ： " + flag + "锁定obj2，休息0.5秒后锁定obj1去！");

try

{

Thread.sleep(500);

}

catch (Exception e)

{

e.printStackTrace();

}

synchronized (object1)

{

System.out.println("线程 : " + flag + "访问object1");

}

}

}

}

}

结果：

2

线程 ： 2锁定obj2，休息0.5秒后锁定obj1去！

1

线程 ： 1锁定obj1，休息0.5秒后锁定obj2去！

对象锁、notifyAll、notify、wait

wait()方法

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。

唤醒当前对象锁的等待线程使用notify或notifyAll方法,wait() 和notify()必须在synchronized函数或synchronized　block中进行调用。

Calculator.java:

//计算线程

public class Calculator extends Thread {

private int total;

public int getTotal() {

return total;

}

public void run() {

synchronized (this) {

for (int i = 0; i 

total += i;

}

// 通知所有在此对象上等待的线程

notifyAll();

}

}

}

ReaderResult.java:

public class ReaderResult extends Thread {

Calculator c;

public ReaderResult(Calculator c) {

this.c = c;

}

public void run() {

synchronized (c) {

try {

System.out.println(Thread.currentThread() + "等待计算结果。。。");

c.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out

.println(Thread.currentThread() + "计算结果为：" + c.getTotal());

}

}

public static void main(String[] args) {

// 启动5个线程，分别获取计算结果

Calculator calculator = new Calculator();

for (int i = 0; i 

new ReaderResult(calculator).start();

}

// 启动计算线程

calculator.start();

}

}

结果：

Thread[Thread-1,5,main]等待计算结果。。。

Thread[Thread-2,5,main]等待计算结果。。。

Thread[Thread-3,5,main]等待计算结果。。。

Thread[Thread-5,5,main]等待计算结果。。。

Thread[Thread-4,5,main]等待计算结果。。。

Thread[Thread-1,5,main]计算结果为：45

Thread[Thread-4,5,main]计算结果为：45

Thread[Thread-5,5,main]计算结果为：45

Thread[Thread-3,5,main]计算结果为：45

Thread[Thread-2,5,main]计算结果为：45

线程jion方法：等待该线程终止。等待调用join方法的线程结束，再继续执行。

public class Main {

static class MyThread implements Runnable {

@Override

public void run() {

// TODO Auto-generated method stub

for (int i = 0; i 

try {

Thread.sleep(1000);

show("XIXI RUN->slower and slower");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

public static void main(String args[]) {

Runnable mRunnable = new MyThread();

Thread t1 = new Thread(mRunnable, "xixi");

t1.start();

try {

t1.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

show("MAIN RUN->CAN YOU BE FAST");

}

private static void show(String str) {

System.out.println(str);

}

}

结果：

XIXI RUN->slower and slower

XIXI RUN->slower and slower

XIXI RUN->slower and slower

XIXI RUN->slower and slower

XIXI RUN->slower and slower

MAIN RUN->CAN YOU BE FAST