1.基本概念图
四个状态、start 代表被创建、run表示正在运行、阻塞(在干别的事情去了,可以把资源空出来给别人用)、死亡。
核心思想是提高cpu的使用率,你干别的事去了我来利用cpu啊,难点是同步,同时访问数据,一个厕所只有一个坑,俩个人一起上是不文明的。
参考:http://blog.csdn.net/zjwcdd/article/details/51517096
2.基本使用方法
俩种常用使用方法,一个是集成Thread类,一种是实现Runnable接口,因为java有单继承的限制,而接口Runnable可以重复实现多次,还可以利用线程池,推荐接口实现方法:
1.继承方法
class JavaThread extends Thread{
private String name;
public JavaThread(String name) {
this.name=name;
}
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + "运行 : " + i);
try {
sleep((int) Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Main {
public static void main(String[] args) {
JavaThread mTh1=new JavaThread("A");
JavaThread mTh2=new JavaThread("B");
mTh1.start();
mTh2.start();
}
}
输出
B运行 : 0
A运行 : 0#可以发现A也可以抢cpu用
B运行 : 1
A运行 : 1
B运行 : 2
A运行 : 2
B运行 : 3
A运行 : 3
B运行 : 4
A运行 : 4
2.实现Runable接口
class JavaThread implements Runnable{
private String name;
public JavaThread(String name) {
this.name=name;
}
@Override//表示实现接口的时候重载了
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + "运行 : " + i);
try {
Thread.sleep((int) Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Main {
public static void main(String[] args) {
new Thread(new JavaThread("C")).start();
new Thread(new JavaThread("D")).start();
}
}
输出
C运行 : 0
D运行 : 0#可以发现D也在抢C的资源
C运行 : 1
D运行 : 1
C运行 : 2
D运行 : 2
C运行 : 3
D运行 : 3
C运行 : 4
D运行 : 4
另外提一点join,主进程做完了想关闭程序,你新建的子进程没干完事也也也也也也直接退出的话会出问题的,join是主进程等你一起退出,这个第一次用的时候坑了我好久。
参考:java多线程吐血整理http://blog.csdn.net/evankaka/article/details/44153709
3.生产者消费者模式
优点:利用很多个生产者(线程)去生产东西,利用很多个消费者(也是线程)去消费生产的东西,好处是利用多线程来处理,省时间。注意 生产者生产东西的总数有个限制,超过就暂时不生产,等消费者消费完,不然会通货膨胀。消费者有东西就消费,没东西就等待。
难点:生产者和消费者之间的数据的同步的问题(一个文件只能同时让一个人在修改,一个厕所只能一个人同时在用)
模式图:
参考:https://www.cnblogs.com/chentingk/p/6497107.html
实现也有很多种方式:
可以参考这个:
生产者/消费者问题的多种Java实现方式http://blog.csdn.net/monkey_d_meng/article/details/6251879
这里举出另外一种:
import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.LinkedBlockingQueue; /** * 多线程模拟实现生产者/消费者模型 * * @author 林计钦 * @version 1.0 2013-7-25 下午05:23:11 */ public class ProducerConsumer { /** * * 定义装苹果的篮子 * */ public class Basket { // 篮子,能够容纳3个苹果 BlockingQueue<String> basket = new LinkedBlockingQueue<String>(3); // 生产苹果,放入篮子 public void produce() throws InterruptedException { // put方法放入一个苹果,若basket满了,等到basket有位置 basket.put("An apple"); } // 消费苹果,从篮子中取走 public String consume() throws InterruptedException { // take方法取出一个苹果,若basket为空,等到basket有苹果为止(获取并移除此队列的头部) return basket.take(); } } // 定义苹果生产者 class Producer implements Runnable { private String instance; private Basket basket; public Producer(String instance, Basket basket) { this.instance = instance; this.basket = basket; } public void run() { try { while (true) { // 生产苹果 System.out.println("生产者准备生产苹果:" + instance); basket.produce(); System.out.println("!生产者生产苹果完毕:" + instance); // 休眠300ms Thread.sleep(300); } } catch (InterruptedException ex) { System.out.println("Producer Interrupted"); } } } // 定义苹果消费者 class Consumer implements Runnable { private String instance; private Basket basket; public Consumer(String instance, Basket basket) { this.instance = instance; this.basket = basket; } public void run() { try { while (true) { // 消费苹果 System.out.println("消费者准备消费苹果:" + instance); System.out.println(basket.consume()); System.out.println("!消费者消费苹果完毕:" + instance); // 休眠1000ms Thread.sleep(1000); } } catch (InterruptedException ex) { System.out.println("Consumer Interrupted"); } } } public static void main(String[] args) { ProducerConsumer test = new ProducerConsumer(); // 建立一个装苹果的篮子 Basket basket = test.new Basket(); ExecutorService service = Executors.newCachedThreadPool(); Producer producer = test.new Producer("生产者001", basket); Producer producer2 = test.new Producer("生产者002", basket); Consumer consumer = test.new Consumer("消费者001", basket); service.submit(producer); service.submit(producer2); service.submit(consumer); // 程序运行5s后,所有任务停止 // try { // Thread.sleep(1000 * 5); // } catch (InterruptedException e) { // e.printStackTrace(); // } // service.shutdownNow(); } }
输出:
生产者准备生产苹果:生产者002
消费者准备消费苹果:消费者001
生产者准备生产苹果:生产者001
!生产者生产苹果完毕:生产者002
!生产者生产苹果完毕:生产者001
An apple
!消费者消费苹果完毕:消费者001
生产者准备生产苹果:生产者001
!生产者生产苹果完毕:生产者001
参考:https://www.cnblogs.com/linjiqin/archive/2013/05/30/3108188.html
4.死锁
锁,同步是解决多线程下保证只有一个线程在处理这个文件的基本方式,我锁住了,别人就不能访问了,直到我不需要了,你才能访问它,上面中的线程安全的队列就是利用这个原理实现的,死锁就是A在等B某个访问结束,B也在等A某个访问结束,俩个都在等,一直等,这样就出现问题了。
总感觉会出现这个问题是因为计算机太傻比了,访问的时候给文件加个锁,谁来我给谁,或者让它等不行吗?不可以吗?可能有另外的开销?为啥对线程上锁?是不是我理解错了。
上图中,就是俩个人都在等,都不服输,就会出现死锁,代码如下:
import java.util.Date;
public class LockTest {
public static String obj1 = "obj1";
public static String obj2 = "obj2";
public static void main(String[] args) {
LockA la = new LockA();
new Thread(la).start();
LockB lb = new LockB();
new Thread(lb).start();
}
}
class LockA implements Runnable{
public void run() {
try {
System.out.println(new Date().toString() + " LockA 开始执行");
while(true){
synchronized (LockTest.obj1) {
System.out.println(new Date().toString() + " LockA 锁住 obj1");
Thread.sleep(3000); // 此处等待是给B能锁住机会
synchronized (LockTest.obj2) {
System.out.println(new Date().toString() + " LockA 锁住 obj2");
Thread.sleep(60 * 1000); // 为测试,占用了就不放
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class LockB implements Runnable{
public void run() {
try {
System.out.println(new Date().toString() + " LockB 开始执行");
while(true){
synchronized (LockTest.obj2) {
System.out.println(new Date().toString() + " LockB 锁住 obj2");
Thread.sleep(3000); // 此处等待是给A能锁住机会
synchronized (LockTest.obj1) {
System.out.println(new Date().toString() + " LockB 锁住 obj1");
Thread.sleep(60 * 1000); // 为测试,占用了就不放
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出就是A锁住了,B锁住了,然后就不动了:
Wed Jan 10 19:36:44 GMT+08:00 2018 LockA 开始执行
Wed Jan 10 19:36:44 GMT+08:00 2018 LockA 锁住 obj1
Wed Jan 10 19:36:44 GMT+08:00 2018 LockB 开始执行
Wed Jan 10 19:36:44 GMT+08:00 2018 LockB 锁住 obj2
后面就没有了
如何避免死锁呢,别一个锁着又去锁另外一个
import java.util.Date;
public class UnLock {
public static String obj1 = "obj1";
public static String obj2 = "obj2";
public static void main(String[] args) {
LockA la = new LockA(obj1,obj2);
new Thread(la).start();
LockB lb = new LockB(obj1,obj2);
new Thread(lb).start();
}
}
class LockA implements Runnable{
private Object obj1;
private Object obj2;
public LockA(Object o1,Object o2){
this.obj1 = o1;
this.obj2 = o2;
}
public void run() {
String name = Thread.currentThread().getName();
System.out.println(name + " acquiring lock on " + obj1);
synchronized (obj1) {
System.out.println(name + " acquired lock on " + obj1);
// work();
}
System.out.println(name + " released lock on " + obj1);
System.out.println(name + " acquiring lock on " + obj2);
synchronized (obj2) {
System.out.println(name + " acquired lock on " + obj2);
// work();
}
System.out.println(name + " released lock on " + obj2);
System.out.println(name + " finished execution.");
}
}
class LockB implements Runnable{
private Object obj1;
private Object obj2;
public LockB(Object o1,Object o2){
this.obj1 = o1;
this.obj2 = o2;
}
public void run() {
String name = Thread.currentThread().getName();
System.out.println(name + " acquiring lock on " + obj2);
synchronized (obj2) {
System.out.println(name + " acquired lock on " + obj2);
// work();
}
System.out.println(name + " released lock on " + obj2);
System.out.println(name + " acquiring lock on " + obj1);
synchronized (obj1) {
System.out.println(name + " acquired lock on " + obj1);
}
System.out.println(name + " released lock on " + obj1);
System.out.println(name + " finished execution.");
}
}
Thread-0 acquiring lock on obj1
Thread-1 acquiring lock on obj2
Thread-0 acquired lock on obj1
Thread-1 acquired lock on obj2
Thread-0 released lock on obj1
Thread-1 released lock on obj2
Thread-0 acquiring lock on obj2
Thread-1 acquiring lock on obj1
Thread-0 acquired lock on obj2
Thread-1 acquired lock on obj1
Thread-0 released lock on obj2
Thread-1 released lock on obj1
Thread-1 finished execution.
Thread-0 finished execution.