黑马程序员——Jave多线程

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

1.多线程：就是指应用程序有多条执行路径。
进程：正在运行的应用程序。
线程：程序的执行单元。执行路径。
举例：
360的管理界面，迅雷下载。
吃饭案例：
单进程单线程：单人一桌菜。
单进程多线程：多人一桌菜。
多进程多线程：多人多桌菜。

2.多线程的实现方案
A:继承Thread类。
步骤：
a.自定义类MyThread继承Thread类。
b.在MyThread类中重写run()方法。
c.在测试类中，创建MyThread类的对象。
d.调用start()方法。
class MyThread extends Thread{
public void run(){
for(int x=0; x<100; x++){
System.out.println(getName()+"---"+x)
}
}
}
测试类：
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();

my1.start();
my2.start();
B:实现Runnable接口。
步骤：
a.自定义类MyRunnable实现Runnable接口。
b.在MyRunnable里面重写run()方法。
c.创建MyRunnable的对象my。
d.创建Thread类的对象，把my对象作为构造参数传递。
e.调用start()方法。
class MyRunnable implements Runnable{
public void run(){
for(int x=0; x<100; x++){
System.out.println(Thread.currentThread().getName()+"---"+x);
/*
* 注意：
* 实现Runnable接口的类本质不是一个线程类。所以，他没有getName()方法。
* 而我们又想知道是哪个线程在执行，所以Thread类里面提供了一个方法获取当前正在执行的线程对象。
* public static Thread currentThread()：返回对当前正在执行的线程对象的引用。 
*/
}
}
}
测试类：
MyRunnable my = new MyRunnable();
Thread t1 = new Thread(my);
Thread t2 = new Thread(my);
t1.start();
t2.start();
问题：
为什么有了继承Thread类的方式，还会有实现Runnable接口的方式？
假如有一个子类，已经有一个父类了，它还想实现多线程，怎么办？
这个时候就不能再继承Thread类了，所以Java就提供了实现Runnable的方式，
一般，推荐使用实现接口的方式。

  run()和start()方法的区别?
  A:run()方法封装了被线程执行的代码，单独使用，仅仅是普通方法的调用。
  B:start()方法调用做了两件事情，首先让线程启动，然后又jvm自动调用run()方法。
3.多线程程序的随机性原理：
CPU在多个程序间做着高效的切换执行。
4.线程的生命周期：
新建
就绪
运行
死亡
5.线程安全问题的产生及解决：
1:产生的原因：
a:是否是多线程
b:是否有共享数据
c:共享数据是否被多条语句操作
2:解决方案：
同步代码块。
synchronized(对象锁) {
被同步的代码。
}


注意：这里的对象锁可以是任意对象。
 但是，一定要保证多个线程使用的锁是同一把。
6.单例设计模式
类在内存中只有一个对象。
如何做到这一点呢?
a.让外界不能创建对象，把无参构造私有。
b.本身提供一个对象。
c.通过公共的方式返回。
(1)饿汉式
进来就造对象。开发用。
        public class Student {
// 构造私有,不让外界创建对象
private Student() {}
// 本身造一个对象
// 加private，是为了不让外界直接访问
// 加static，是因为静态只能访问静态
private static Student s = new Student();
// 公共的访问方式
// 为了让外界可以直接使用，用静态修饰
public static Student getStudent() {
return s;
}
public void show() {
System.out.println("show");
}
}
测试类：
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1 == s2);
s1.show();
s2.show();
(2)懒汉式
用的时候才造对象。面试用.
延迟加载。懒加载。
线程安全问题。
public class Teacher {
private Teacher() {}
private static Object obj = new Object();
private static Teacher t = null;
public static Teacher getTeacher() {
synchronized (obj) {
if (t == null) {
t = new Teacher();
}
}
return t;
}
public void show() {
System.out.println("show");
}
}
测试类：
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
System.out.println(t1 == t2);
t1.show();
t2.show();
7.线程安全的类：
StringBuffer
Vector
Hashtable
8.多线程中同步的方式：
1:同步代码块
锁对象是任意对象。
2:同步方法
锁对象是this对象。
注意：
静态方法的锁对象是当前类的字节码文件对象。
9.几个小方法：
A.线程优先级
线程的默认优先级是5。
  线程的优先级范围是：1-10。
  优先级只有在次数特别多的时候，才可能让你看到级别高的能优先执行。
public final int getPriority():获取线程优先级
public final void setPriority(int newPriority):更改线程优先级
B.加入线程
public final void join()
让其他的线程等待，直到加入线程执行完毕。
C.暂停线程
暂停当前正在执行的线程对象，并执行其他线程。 
public static void yield()
暂停线程的作用是为了让线程间数据的执行更和谐一些。
但是，不能依赖它来是实现一人一次，要想真正实现，就得用等待唤醒机制。
D.守护线程
当正在运行的线程都是守护线程时，Java 虚拟机退出。 
public final void setDaemon(boolean on)
10.开发的用法：
用匿名内部类的方式。

                new Thread(){
...
}.start();


new Thread(new Runnable(){
...
}.start();

11.JDK5以后的Lock锁对象。可以让我们非常明确的看到在哪里加上锁，在哪里释放锁。