黑马程序员_java基础之多线程

------- android培训、java培训、期待与您交流！ ----------

1.Thread： 

程序中的执行线程。在Java 虚拟机允许应用程序同时运行多个执行线程。

创建线程的3种方式：
方式1： 继承Thread类
1: 创建自定义类，继承于 Thread
2: 在自定义类中，重写Thread类中的run()方法
3: 创建自定义类对象，调用start()方法

方式2： 实现Runnable接口
1: 创建自定义类， 实现Runnale接口
2: 在自定义类中，实现Runnable接口中的run()方法
3: 创建自定义类对象
4: 通过Thread类，创建线程对象，并把自定义对象作为参数使用
5: 启动线程对象

方式3：线程池方式，通过submit()方法，调用Callable接口子类对象
1:继承Thread类
2:Runnable接口
3:通过线程池，访问Callable接口子类对象

2.方式1： 继承Thread类

继承Thread类
1: 创建自定义类，继承于 Thread
2: 在自定义类中，重写Thread类中的run()方法
3: 创建自定义类对象，调用start()方法

//1: 创建自定义类，继承于 Threadpublic class MyThread extends Thread {public MyThread() {super();}public MyThread(String name) {super(name);}//2: 在自定义类中，重写Thread类中的run()方法@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + "---"+i);}}}public class ThreadDemo {public static void main(String[] args) {//3: 创建自定义类对象，调用start()方法//MyThread t1 = new MyThread();//MyThread t2 = new MyThread();//通过构造方法，为线程起名字MyThread t1 = new MyThread("小李");MyThread t2 = new MyThread("小王");//开启线程t1.start();t2.start();}}

3.方式2： 

实现Runnable接口

1: 创建自定义类， 实现Runnale接口
2: 在自定义类中，实现Runnable接口中的run()方法
3: 创建自定义类对象
4: 通过Thread类，创建线程对象，并把自定义对象作为参数使用
5: 启动线程对象

public class MyRunnable implements Runnable {//1: 创建自定义类， 实现Runnale接口//2: 在自定义类中，实现Runnable接口中的run()方法@Overridepublic void run() {for (int i = 0; i < 100; i++) {//System.out.println(getName() + "--" + i);System.out.println(Thread.currentThread().getName() + "--"+i );}}}public class ThreadDemo {public static void main(String[] args) {//3: 创建自定义类对象MyRunnable my = new MyRunnable();//4: 通过Thread类，创建线程对象，并把自定义对象作为参数使用//Thread t1 = new Thread(my);//Thread t2 = new Thread(my);Thread t1 = new Thread(my, "小李");Thread t2 = new Thread(my, "小王");t1.start();t2.start();}}

4.方式3

线程池方式，通过submit()方法，调用Callable接口子类对象
1:继承Thread类
2:Runnable接口
3:通过线程池，访问Callable接口子类对象

<pre name="code" class="java">import java.util.concurrent.Callable;public class MyCallable implements Callable {<span style="white-space:pre"></span>@Override<span style="white-space:pre"></span>public Object call() throws Exception {<span style="white-space:pre"></span>System.out.println("Java真好");<span style="white-space:pre"></span>System.out.println(Thread.currentThread().getName());<span style="white-space:pre"></span>return null;<span style="white-space:pre"></span>}}import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ThreadDemo {public static void main(String[] args) {//创建线程池对象ExecutorService service =  Executors.newFixedThreadPool(3); //创建Callable接口子类对象MyCallable my1 = new MyCallable();MyCallable my2 = new MyCallable();MyCallable my3 = new MyCallable();//获取线程池中的线程对象，调用Callable接口子类对象中的call()方法service.submit(my1);service.submit(my2);service.submit(my3);}}

5.同步有3种方式

方式1： 同步代码块
锁对象： 任意对象
方式2： 同步方法
锁对象： this
方式3： 同步静态方法
锁对象： 类名.class
6.单例设计模式

public class Single {//饿汉式//构造方法私有private Single(){}//在当前类中， 创建一个当前类对象,并私有private static Single s = new Single();//在当前类中，提供一个public方法，用来获取到创建好的对象public static Single getInstance(){return s;}}//懒汉式public class Single2 {private Single2(){}private static Single2 s = null;public synchronized static Single2 getInstance(){if (s == null) {s = new Single2();}return s;}}

6.sleep()和wait()方法的区别

sleep(): 休眠
要等待时间到达后，自动醒来
释放CPU执行权，但不释放锁对象

wait(): 等待
可以等待时间到达后，自动醒来
或者可以通过notify() 或 notifyAll()唤醒
释放CPU执行权，同时释放锁对象

7.线程的生命周期

新建--就绪--运行--死亡      

新建--就绪--运行--阻塞--就绪--运行--死亡

run()和start()的区别

run(): 用来指定线程对象要执行的任务
start(): 启动线程，通过JVM底层调用当前线程对象的run()方法

8.一个手机生产和卖手机的案例

public class Phone {public String brand;//品牌public String color;//颜色public boolean isNewPhone = false;//当前变量代表是否有新手机//true : 代表有新手机， 不生产，等待购买//false: 代表没有新手机,不购买，等待生产}public class Producer implements Runnable {<span style="white-space:pre"></span>//<span style="font-family: Arial, Helvetica, sans-serif;">生产者： Producer， 生产手机</span>private Phone p;int num = 0;public Producer(Phone p) {this.p = p;}@Overridepublic void run() {while (true) {synchronized (p) {//1： 判断是否有新手机if (p.isNewPhone) {//有的话，就等待try {p.wait();} catch (InterruptedException e) {e.printStackTrace();}}//2：如果代码执行到了这里，说明，没有新手机，生产手机生产手机模拟生产时间try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}if (num%2 == 0 ) {p.brand = "华为";p.color = "黑色";} else {p.brand = "小米";p.color = "土豪金";}System.out.println("生产了：" + p.brand +"--"+ p.color);num++;//3：更新新手机的标识 为 truep.isNewPhone = true;//4：通知消费者，购买手机p.notify();}}}}public class Consumer implements Runnable {<span style="white-space:pre"></span>//<span style="font-family: Arial, Helvetica, sans-serif;">消费者： Consumer, 购买手机</span>private Phone p;public Consumer(Phone p) {this.p = p;}@Overridepublic void run() {while (true) {synchronized (p) {//1： 判断是否有新手机if (! p.isNewPhone) {//没有的话，就等待try {p.wait();} catch (InterruptedException e) {e.printStackTrace();}}//2：如果执行到了这里，说明有新手机购买手机模拟付款try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("购买了 : "+ p.brand + "--" + p.color);//3：更新新手机的标识 为 falsep.isNewPhone = false;//4:通知生产商，生产手机p.notify();}}}}public class Test {public static void main(String[] args) {//定义一台手机Phone p = new Phone();//创建Runnable接口子类对象Producer producer = new Producer(p);Consumer consumer = new Consumer(p);//创建线程对象 Thread producerThread = new Thread(producer, "生产商");Thread consumerThread = new Thread(consumer, "消费者");//启动线程producerThread.start();consumerThread.start();}}