JAVA多线程学习小结
一、线程概念：线程是比进程更小的执行单元。一个进程中可以有多个线程
二、多线程优点：提高了程序的执行效率、充分利用资源、使程序同步执行（Java的垃圾回收机制运用了多线程。）
三、进程与线程的区别
线程与进程的区别可以归纳为以下4点：
1）地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
2）通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
3）调度和切换：线程上下文切换比进程上下文切换要快得多。
4）在多线程OS中，进程不是一个可执行的实体。
四、创建多线程的两个方法
1.继承Thread类。
步骤：
a.继承Thread类，覆盖（重写）run方法。
b.创建线程（即创建对象时线程也就被创建了）。
c.启动线程。
实例：
class ThreadDemo extends Thread{
public void run(){
//你要执行的程序块
}
}
public class Demo{
public static void main(String args[]){
ThreadDemo td=new ThreadDemo(); //创建线程
td.start();//启动线程
}
}
2.实现Runnable接口。
步骤：
a.定义类实现Runnable接口。
b.覆盖Runnable接口中的run方法。
c.通过Thread类建立线程对象。
d.将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法。
e.调用Thread类的start方法开启线程。
实例：
class ThreadDemo implements Runnable{
public void run{
//你要执行的程序块
}
}
public class Demo{
public static void main(String args[]){
Thread thread=new Thread(new ThreadDemo());//创建线程
thread.start();//启动线程
}
}
五、实现方式与继承方式的区别
a.继承Thread：线程代码存放在Thread子类的run方法中。
b.实现Runnable:线程代码在接口子类的run方法。
注：使用实现方式的好处是避免了单继承的局限性。在定义线程时，建议使用实现方式。同时也满足面向对象设计的模式之一，即面向接口编程的思想。
六、使用多线程时几个很重要的方法
每个线程都有自己的名称：默认为：Thread-编号。
两个方法：getName()、setName().
还可以用构造方法传入。父类有这个构造方法。可以调用super(name);
currentThread()获取当前进程对象。是静态的，可以通过类名调用。
七、多线程的安全问题
原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一个线程参与进来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与。
Java对多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchroized(对象)
用synchroized修饰函数使其成为同步函数，给某个线程加锁，上锁后不允许其他线程同时来共享此数据块。
同步函数用的是哪一个锁？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所有同步函数使用的锁是this.
两个要点：1.多个线程存在。2.同一个锁。
如果同步函数被静态类修饰后，使用的锁是什么呢？
在静态方法中不可以定义this.静态进内存，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class 该对象的类型是Class.
SO :静态的同步方法，使用的锁是该方法所在类的字节码文件对象,类名.class.
八、多线程中thread.run()与thread.start()的区别
thread.start()开启了线程，才会实现程序的多线程执行。
thread.run()方法仅仅只是调用了方法，没开启线程，也就无法实现多线程。运行时不会不断的先后抢占CPU资源，而是调用后全部执行完。
九、单例模式中的多线程（*）
//单例模式：私有化构造方法不允许类外创建对象，一般推荐使用饿汉式，因为懒汉式容易产生线程不安全问题
/*
饿汉式
class Single{
private static final Single s=new Single();
private Single();
public static Single getInstance(){
return s;
}
}
*/
class Single { //懒汉式
private static Single s=null;
private Single(){}
public static Single getInstance(){
if(s==null){
synchronized(Single.class){ //同步修饰防止发生线程不安全问题
if(s==null)
s=new Single();
}
}
}
}
public class SingleDemo {
public static void main(String[] args) {
}
}
十、死锁问题（*）
class Test implements Runnable
{
private boolean flag;
Test(boolean flag){
this.flag=flag;
}
public void run(){
if(flag){
synchronized(MyLock.locka){
System.out.println("if MyLock.locka");
synchronized(MyLock.lockb){
System.out.println("if MyLock.lockb");
}
}
}
else{
synchronized(MyLock.lockb){
System.out.println("else MyLock.lockb");
synchronized(MyLock.locka){
System.out.println("else MyLock.locka");
}
}
}
}
}
class MyLock
{
static Object locka=new Object();
static Object lockb=new Object();
}
class DeadLockTest {
public static void main(String[] args) {
Thread t1=new Thread(new Test(true));
Thread t2=new Thread(new Test(false));
t1.start();
t2.start();
}
}
