package cc150.thread_lock;
public class RunnableThreadExample implements Runnable{
public int count = 0;
public static void main(String[] args) {
// TODO 自动生成的方法存根
RunnableThreadExample instance = new RunnableThreadExample();
Thread thread = new Thread(instance);
thread.start();
//等到上面的线程数到5
while(instance.count != 5){
try{
Thread.sleep(250);
System.out.println("等待");
}catch(InterruptedException exc){
exc.printStackTrace();
}
}
}
@Override
public void run() {
// TODO 自动生成的方法存根
System.out.println("RunnableThread开始");
try{
while(count < 5){
Thread.sleep(500);
count++;
}
}catch(InterruptedException exc){
System.out.println("RunnableThread中断");
}
System.out.println("RunnableThread终止");
}
}
package cc150.thread_lock;
public class ThreadExample{
public static void main(String[] args){
// TODO 自动生成的方法存根
ThreadExample th = new ThreadExample();
threadExample instance = th.new threadExample();
instance.start();
//等到上面的线程数到5
while(instance.count != 5){
try{
Thread.sleep(250);
System.out.println("等待");
}catch(InterruptedException exc){
exc.printStackTrace();
}
}
}
public class threadExample extends Thread{
int count = 0;
public void run() {
// TODO 自动生成的方法存根
System.out.println("Thread开始");
try{
while(count < 5){
Thread.sleep(500);
System.out.println("在线程中，count是"+count);
count++;
}
}catch(InterruptedException exc){
System.out.println("RunnableThread中断");
}
System.out.println("RunnableThread终止");
}
}
}
package cc150.thread_lock;
class MyObject{
public synchronized void foo(String name){ //加上synchronized关键字，给foo提供同步
try{
System.out.println("线程"+name+".foo()开始");
Thread.sleep(3000);
System.out.println("线程"+name+".foo()结束");
}catch(InterruptedException exc){
System.out.println("线程"+name+"中断");
}
}
}
public class MyClass extends Thread{ //不同的线程，来调用上面的foo
private String name;
private MyObject myObj;
public MyClass(MyObject obj,String n){
name = n;
myObj = obj;
}
public void run(){
myObj.foo(name);
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
// MyObject obj1 = new MyObject();
// MyObject obj2 = new MyObject();
// MyClass thread1 = new MyClass(obj1,"1");
// MyClass thread2 = new MyClass(obj2,"2");
// thread1.start();
// thread2.start();
//相同的obj引用，只能一个线程可以调用foo，另一个线程必须等待
MyObject obj = new MyObject();
MyClass thread11 = new MyClass(obj,"1");
MyClass thread22 = new MyClass(obj,"2");
thread11.start();
thread22.start();
}
}
package cc150.thread_lock;
class MyObject{
public static synchronized void foo(String name){ //加上synchronized关键字，给foo提供同步
try{
System.out.println("线程"+name+".foo()开始");
Thread.sleep(3000);
System.out.println("线程"+name+".foo()结束");
}catch(InterruptedException exc){
System.out.println("线程"+name+"中断");
}
}
public static synchronized void bar(String name){ //加上synchronized关键字，给bar提供同步
try{
System.out.println("线程"+name+".bar()开始");
Thread.sleep(3000);
System.out.println("线程"+name+".bar()结束");
}catch(InterruptedException exc){
System.out.println("线程"+name+"中断");
}
}
}
public class MyClass extends Thread{ //不同的线程，来调用上面的foo
private String name;
private MyObject myObj;
public MyClass(MyObject obj,String n){
name = n;
myObj = obj;
}
public void run(){
//myObj.foo(name);
if(name.equals("1"))
MyObject.foo(name);
else if(name.equals("2"))
MyObject.bar(name);
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
// MyObject obj1 = new MyObject();
// MyObject obj2 = new MyObject();
// MyClass thread1 = new MyClass(obj1,"1");
// MyClass thread2 = new MyClass(obj2,"2");
// thread1.start();
// thread2.start();
//相同的obj引用，只能一个线程可以调用foo，另一个线程必须等待
MyObject obj = new MyObject();
MyClass thread11 = new MyClass(obj,"1");
MyClass thread22 = new MyClass(obj,"2");
thread11.start();
thread22.start();
}
}
package cc150.thread_lock;
class MyObject2{
public synchronized void foo(String name){ //加上synchronized块，给foo提供同步
synchronized(this){
try{
System.out.println("线程"+name+".foo()开始");
Thread.sleep(3000);
System.out.println("线程"+name+".foo()结束");
}catch(InterruptedException exc){
System.out.println("线程"+name+"中断");
}
}
}
}
public class MyClass2 extends Thread{ //不同的线程，来调用上面的foo
private String name;
private MyObject2 myObj;
public MyClass2(MyObject2 obj,String n){
name = n;
myObj = obj;
}
public void run(){
myObj.foo(name);
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
// MyObject obj1 = new MyObject();
// MyObject obj2 = new MyObject();
// MyClass thread1 = new MyClass(obj1,"1");
// MyClass thread2 = new MyClass(obj2,"2");
// thread1.start();
// thread2.start();
//相同的obj引用，只能一个线程可以调用foo，另一个线程必须等待
MyObject2 obj = new MyObject2();
MyClass2 thread11 = new MyClass2(obj,"1");
MyClass2 thread22 = new MyClass2(obj,"2");
thread11.start();
thread22.start();
}
}
package cc150.thread_lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class MyObj {
private Lock lock;
private int balance = 100; //剩余
public MyObj(){ //构造函数
lock = new ReentrantLock(); //可重入锁
}
public int withdraw(int value){ //取款
lock.lock();
int temp = balance;
try{
Thread.sleep(100);
temp = temp-value;
Thread.sleep(100);
balance = temp;
}catch(InterruptedException e){
}
lock.unlock();
return temp;
}
public int deposit(int value){ //存款
lock.lock();
int temp = balance;
try{
Thread.sleep(100);
temp = temp+value;
Thread.sleep(100);
balance = temp;
}catch(InterruptedException e){
}
lock.unlock();
return temp;
}
}
public class LockedATM extends Thread{
private int value;
private MyObj myObj;
private String str;
public LockedATM(MyObj obj,String s,int v){
value = v;
myObj = obj;
str = s;
}
public void run(){
if(str.equals("withdraw"))
System.out.println(myObj.withdraw(value));
else if(str.equals("deposit"))
System.out.println(myObj.deposit(value));
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
MyObj obj1 = new MyObj();
MyObj obj2 = new MyObj();
LockedATM thread1 = new LockedATM(obj1,"withdraw",50); //两个线程执行的顺序不一定
LockedATM thread2 = new LockedATM(obj2,"deposit",50); //可能先存款，也可能先取款
thread1.start();
thread2.start();
}
}
