线程锁与多线程

package day20150914sync;
/**
* 线程并发安全问题
*/
public class SyncDemo1 {
//桌子上有20个豆子
public static int beans = 20;
public static void main(String[] args) {
Thread t1 = new Thread(){
public void run(){
int bean = 0;
while(true){
bean = getBean();
Thread.yield();//让线程延迟
System.out.println(this.getName()+":"+bean);
}
}
};

Thread t2 = new Thread(){
public void run(){
int bean = 0;
while(true){
bean = getBean();
Thread.yield();//让线程延迟
System.out.println(this.getName()+":"+bean);
}
}
};

t1.start();
t2.start();
}
/**
* synchronized:加锁之后，
* 单个线程彻底运行完方法后才释放锁
* 方法锁的对象是this
*/
public synchronized static int getBean(){
if(beans==0){
throw new RuntimeException("没豆子了");
}
try {
Thread.sleep(50);//sleep50毫秒
} catch (InterruptedException e){
e.printStackTrace();
}
return beans--;

}

}
/*
* 备注：
* StringBuffer:线程安全
* StringBuilder:线程不安全
*
* 例如append的时候
*/

package day20150914sync;
/**
* 有效减少同步范围可提高效率
*
*/
public class SyncDemo2 {
private static Object obj = new Object();
public static void main(String[] args) {
Thread t1 = new Thread(){
public void run(){
buy(this.getName());//静态方法不用点“.”
}
};
Thread t2 = new Thread(){
public void run(){
buy(this.getName());
}
};

t1.start();
t2.start();
}
//锁住整个方法，类作为锁，当前线程完全执行完方法后，其他线程才可使用此方法
//public static synchronized void buy(String name){

public static void buy(String name){
System.out.println(name+"挑衣服");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//多个线程看到的是同一个对象，才具有同步效力
/*
* 如果synchronized块在某一个非静态方法中，
* 那么通常锁对象写的是this
*
* 静态方法中不能使用非静态对象
*/
synchronized (obj) {
System.out.println(name + "开始试衣服。。。");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + "试衣服结束。。。");
}
System.out.println(name+"结账");
}
}

package day20150914sync;
/**
* 有效减少同步范围可提高效率（非静态方法）
*/
public class SyncDemo3 {
public static void main(String[] args) {
//匿名内部类使用demo,需要是final
final SyncDemo3 demo = new SyncDemo3();
Thread t1 = new Thread(){
public void run(){
demo.buy(this.getName());//匿名内部类使用demo,需要是final
}
};
Thread t2 = new Thread(){
public void run(){
demo.buy(this.getName());
}
};

t1.start();
t2.start();
}
/**非静态方法
*/
public void buy(String name){
System.out.println(name+"挑衣服");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//多个线程看到的是同一个对象，才具有同步效力
/*
* 如果synchronized块在某一个非静态方法中，
* 那么通常锁对象写的是this
*
* 静态方法中不能使用非静态对象
*/
synchronized (this) {
System.out.println(name + "开始试衣服。。。");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + "试衣服结束。。。");
}
System.out.println(name+"结账");
}
}

package day20150914sync;

public class ThreadDemo4join {

/**
* 图片是否下载完
*/
public static boolean isFinish;
public static void main(String[] args) {
final Thread download = new Thread(){
public void run(){
/*
* 下载图片
*/
System.out.println("开始下载图片。。。");
for(int i=1;i<=10;i++){
System.out.println(i+"0%");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("图片下载完成");
isFinish = true;

/*
* 下载附件
*/
System.out.println("开始下载附件");
for(int i=1;i<=10;i++){
System.out.println(i+"0%");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("附件下载完成");
}
};
/**
* 显示图片
*
* main方法中定义了一个内部类show
* 该内部类中若想引用main方法中的其他局部变量
* 那么这个变量必须是final的
*/
Thread show = new Thread(){
public void run(){
//这里等待图片下载完成
try {
download.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("开始显示图片");
if(!isFinish){
throw new RuntimeException("图片还没有下载完成");
}
System.out.println("图片打开");
}
};

download.start();
show.start();

}

}

package day20150914sync;

public class ThreadDemo5waitnotify {

/**
* 图片是否下载完
*/
private static boolean isFinish;
private static final Object obj = new Object();
public static void main(String[] args) {
final Thread download = new Thread(){
public void run(){
/*
* 下载图片
*/
System.out.println("开始下载图片。。。");
for(int i=1;i<=10;i++){
System.out.println(i+"0%");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("图片下载完成");
isFinish = true;
synchronized(obj){
/*
* 图片下完，就当通知去显示图片
* notify()需要加锁
* notify()只会随机基础一个在当前对象等待的线程
* notifyAll()全解除
*
* 调用哪个对象的wait或notify,就应当对当前方法加锁
* 锁对象就是当前对象
*/
obj.notify();//notifyAll():全部解除在等待的所有线程
}

/*
* 下载附件
*/
System.out.println("开始下载附件");
for(int i=1;i<=10;i++){
System.out.println(i+"0%");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("附件下载完成");
}
};
/**
* 显示图片
*
* main方法中定义了一个内部类show
* 该内部类中若想引用main方法中的其他局部变量
* 那么这个变量必须是final的
*/
Thread show = new Thread(){
public void run(){
//这里等待图片下载完成
try {
//download.join();
synchronized(obj){
//在obj对象上等待，要加锁
obj.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("开始显示图片");
if(!isFinish){
throw new RuntimeException("图片还没有下载完");
}
System.out.println("图片打开");
}
};

download.start();
show.start();

}

}

package day20150914sync;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CollectionsSynchronized6 {
/**
* 将集合或Map转为线程安全的
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");

//将List集合转为线程安全的
list = Collections.synchronizedList(list);
System.out.println(list);

//将Set集合转为线程安全的
Set<String> set = new HashSet<String>();
set = Collections.synchronizedSet(set);
//将Map转为线程安全的
Map<String, Integer> map = new HashMap<String, Integer>();
map = Collections.synchronizedMap(map);

}

}

package day20150914sync;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* 线程池：
* 1：控制线程数量
* 2：重用线程
*/
public class ThreadPool7 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(2);
for(int i=0;i<5;i++){
Runnable runn = new Runnable(){

@Override
public void run() {
for(int i=0;i<4;i++){
System.out.println(i);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

};
//Thread t = new Thread(runn);
//t.start();
threadPool.execute(runn);
}
}

}