package caokangnsd;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadAndExcutorS {
/*
* 这里打算从线程池开始线程
*/
// 进程和线程的关系，进程可以包含多个线程，进程在内存上有一块空间，线程活跃在这个空间内
// 线程的并发，这也是线程存在的意义，线程可以使多个业务同时进行，但又不是同时的，是分别获取cpu时间片运行的，尽可能
// 均匀分配给各个程序，cpu在同一时间只能干一个事情，其他的线程则停止
// new-runnable-run-blocked-dead
public static void main(String[] args) {
/*
* 現在我們新建一個線程
*/
//1
Thread t1 = new Thread();
// 很显然需要有一个执行的方法和业务
Thread t2 = new Thread() {
public void run() {// 非常重要的run方法
System.out.println("haha");
}
};
t2.start();
//2
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("heihei");
}
});
t3.setPriority(Thread.MAX_PRIORITY);// 设置线程的优先级为最高的10
t3.start();
// 当然你也可以重写类继承他们
// 获取相关信息的方法
System.out.println(t2.getId());
System.out.println(t2.getName());
System.out.println(t2.getPriority());
System.out.println(t2.isAlive());
System.out.println(t2.isDaemon());
System.out.println(t2.isInterrupted());
System.out.println(Thread.currentThread());
//
Thread tr = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 50; i++) {
if (i > 30 & i < 40) {
Thread.yield();// yield，放弃本次时间片等待下次
} else {
System.out.println(i);
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
//
Thread tr1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 100; i < 150; i++) {
try {
Thread.sleep(100);// sleep
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
System.out.println(i);
try {
tr.join();// 充分说明只有join的线程的run方法结束之后才会继续运行
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// try {
// tr.wait();
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// if(i>150) {
// tr.notify();
// }
}
}
});
tr1.setDaemon(true);// deamon，所有非守护线程结束则自动结束
// tr.start();
// tr1.start();
/*
* 锁机制 所谓异步操作是指多线程并发的操作，相当于各干各的。 所谓同步操作是指有先后顺序的操作，
* 相当于你干完我再干。当一个资源被多个线程共同访问时，为了保证共享资源的互斥访问需要加一个
* 先来后到。
* synchronized&Lock
* synchronized对象监视器Contention List》》Entry List》》Owner；队列
* 当线程通过锁时是不能被Thread.interrupt()中断的
*
* Lock，是一个类不在是java的内置语言，需要手动释放
* ReentrantLock,公平锁和非公平锁，可以设置为公平锁
*
*/
// 举例
Test2 test = new Test2();
Thread td = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
test.add();
}
});
Thread td1 = new Thread(new Runnable() {
@Override
public void run() {
test.add();
}
});
td.start();
td1.start();
/*
* 最后得出的结论，当锁住一个方法或一个区域后，
* 1，不用线程调用相同对象test的相同锁方法add2则会排队，不同锁方法（非静态）会互斥排队
* 2，调用锁区域的时候，只有相同才会排队，且锁区域不会锁住对象
* 3，静态方法的锁只在类调用时有用
*/
//并发的 原子性 可见性 有序性
//volatile修饰变量保证每次线程调用时都会读取一下值
/*
*
* 线程池的使用
*
*/
//我们已知的线程Executor->ExecutorService->AbstractExecutorService->ThreadPoolExecutor
//我们需要去了解几种线程池的使用和ThreadExcutorService
//1，固定大小的线程池
Thread test1=new Thread();
ExecutorService ts=Executors.newFixedThreadPool(50);
ts.execute(test1);//这个空线程已经加入了线程池
ts.shutdown();//关闭线程池
//2，管理时间的线程池
ScheduledExecutorService ss=Executors.newScheduledThreadPool(20);
ss.scheduleAtFixedRate(test1, 1, 3, TimeUnit.SECONDS);//延时一秒每3秒执行一次
//3，
ThreadPoolExecutor tpe=new ThreadPoolExecutor(20, 20, 20,
TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(10));
//核心池20个最大20个20秒，队列内10个
tpe.execute(test1);
tpe.submit(test1);//
/*
* 大概是这样设置的，当线程池的大小大于core大小时，进入的线程进入缓存队列，当到达时间后，如果
* 缓存中的线程仍然没有得到利用，那么终止
*
* 另外还有制造线程的线程工厂暂时不做讨论
*
*/
}
}
//
class Test2 {
private static List<String> list = new ArrayList<String>();
public void add() {
System.out.println(Thread.currentThread());
synchronized (list) {
for (int i = 0; i < 10; i++) {
list.add(i + "");
System.out.println(i);
}
}
}
public synchronized void add2() {
System.out.println(Thread.currentThread());
for (int i = 0; i < 50; i++) {
list.add(i + "");
System.out.println(i);
}
}
public synchronized static void add3() {
System.out.println(Thread.currentThread());
for (int i = 0; i < 50; i++) {
list.add(i + "");
System.out.println(i);
}
}
public List getList() {
return list;
}
public void de() {
list.remove(0);
}
}
