线程基础

创建线程

---

1.继承Thread ，重写里面 run 方法

public class Sell1 extends Thread {

    public void run() {
        while (true) {
                try {
                    sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                ...
        }
    }

    public static void main(String[] args) {
        Sell1 sell1 = new Sell1();
        Thread thread1 = new Thread(sell1);
        thread1.start();
    }

}

2.实现runnable 接口， 把实现了runnable接口的对象，放到thread的构造函数里面

public class Sell3 implements Runnable {

    public void run() {
        while (true) {
                    try {
                        Thread.currentThread().sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    ...
        }
    }

    public static void main(String[] args) {
        Sell3 sell3 = new Sell3();
        new Thread(sell3) {}.start();
    }
}

3.匿名内部类：两种写法

new Thread() {
    // 重写父类的run方法，Thread的子类，没有名字 -> 匿名内部类
    public void run() {
    }
}.start();

new Thread(new Runnable() {
    // 实现接口的方法，接口的子类, 没有名字 -> 匿名内部类
    public void run() {
    }
}).start();

线程常用的方法

---

1.类方法(静态)：
Thread.sleep(long m); //休眠
Thread.currentThread（）； //当前线程

2.对象方法 [ t = new Thread(); ] :
t.start() ; // 开启线程
t.getName(); //得到当前线程的名字

线程安全问题(synchronized同步)

---

1.线程产生安全问题的原因:

1. 多个线程
2. 修改公共资源
3. run方法内多句代码

2.解决办法

1. 同步方法

public synchronized void run() {
        while (true) {
                try {
                    Thread.currentThread().sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
        }
    }

1. 同步代码块(同步对象是object , this , 静态类.class)

    Object obj = new Object();
    public void run() {
        while (true) {
            synchronized (obj) {
                    try {
                    //此处只有一条语句
                        Thread.currentThread().sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
            }
        }
    }

3.同步优缺点 :
耗时但保证了线程安全 ;

单例模式 :

---

package synchronize;

//单例的原因:构造方法是私有的,我们不能直接new一个对象出来;
public class Singleton {
    //恶汉模式:所以我们先自行new一个对象,再用一个公有方法返回这个对象;
    // private static Singleton Instance=new Singleton();
    //
    // public synchronized static Singleton getInstance(){
    // return Instance ;
    // }


    //懒汉模式;一上来只是定义一个对象并不初始化,之后在一个公有方法里初始化它,并返回
    private static Singleton instance;

    public Singleton getInstance() {
        if (instance == null) {// 解决效率问题,所以不写同步方法
            synchronized (Singleton.class) {// 解决线程安全问题
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
    }
}

死锁问题

---

1.产生原因:

1. 锁的相互嵌套
2. 多个线程公用几把锁,拿到锁后互不相让,只有拿到全部的锁才释放

2.死锁产生示例

package synchronize;

public class Dead implements Runnable {
    String name;
    static String one = new String();//锁1
    static String two = new String();//锁2

    Dead(String name) {
        this.name = name;
    }

    public void run() {
        if ("Ly".equals(this.name)) {
            synchronized (one) {
                System.out.println("Ly拿到第一把锁");
                try {
                //因为现在电脑跑得越来越快了,根本锁不住;
                //但是增加代码条数或者休眠一段时间可以成功锁住
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (two) {
                    System.out.println("Ly拿到第二把锁");
                }
            }
        } else {
            synchronized (two) {
                System.out.println("Xx拿到第二把锁");
                synchronized (one) {
                    System.out.println("Xx拿到第一把锁");
                }
            }
        }
    }

    public static void main(String[] args) {
        Dead dead1 = new Dead("Ly");
        new Thread(dead1) {
        }.start();
        Dead dead2 = new Dead("Xx");
        new Thread(dead2) {
        }.start();
    }
}

wait和sleep

---

lock和synchronized

---

public void set() {
   lock.lock();//锁住
    try {
       ...   
    } finally {
      lock.unlock();//释放锁,必须执行!!!
    }
}

wait , notify , notify all

---

1.作用:

1. wait 会释放cpu,释放锁
2. notify 是唤醒一个等待线程,进入可执行状态
3. notifyAll 唤醒所有等待池中的线程
   锁对象调用 ,必须在同步里面!!

2.java.lang.IllegalMonitorStateException非法监控异常
解决办法:锁对象.wait() , 锁对象.notify();

3.示例:妖的故事

String name;
String sex;
Object lock = new Object();
int x = 0;

class Set implements Runnable {
    public void run() {
        while (true) {
          public synchronized void set() {
              if (x == 0) {
                  name = "男";
                  sex = "男";
              } else {
                  name = "女";
                  sex = "女";
              }
              notify();
              try {
                  wait();//释放CPU和锁
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              x++;
              x %= 2;
         }
       }
    }
}

class Get implements Runnable {
    public void run() {
        while (true) {
           public synchronized void get() {
               System.out.println(name + "  " + sex);
               notify(); // 唤醒一个wait等待的线程
               try {
                   wait();//释放CPU和锁
               } catch (InterruptedException e) {
                   e.printStackTrace();
                }
           }
        }
    }
}

public static void main(String[] args) {
    Resource resource = new Resource();
    Set set = resource.new Set();
    Get get = resource.new Get();
    new Thread(set).start();
    new Thread(get).start();
}

线程池

---

示例:

package threadPool;

import java.util.ArrayList;

public class MyThreadPool {
    static ArrayList<MyTask> list = new ArrayList<MyTask>();

    public MyThreadPool(int i) {
        for (int j = 0; j < i; j++) {
            MyWorkThread thread = new MyWorkThread(list);
        }
    }

    public static void adds(MyTask myTask) {
        synchronized (list) {
            list.add(myTask);
            list.notify();
        }
    }

}

package threadPool;

import java.util.ArrayList;

public class MyWorkThread implements Runnable {
    ArrayList<MyTask> list;

    MyWorkThread(ArrayList<MyTask> list) {
        this.list = list;
        new Thread(this).start();
    }

    public void run() {
        while (true) {
            synchronized (list) {
                if (list != null && list.size() > 0) {
                } else {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            MyTask remove = list.remove(0);
            remove.task();
        }
    }
}

package threadPool;

public class MyTask extends Thread {
    String name;

    public MyTask(String string) {
        name = string;
    }

    public void task() {
        System.out.println(name + Thread.currentThread().getName() + "~~~");
    }

}

package threadPool;

public class Test {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(5);
        MyTask my = new MyTask("~~");
        pool.adds(my);
        pool.adds(my);
        pool.adds(my);
        pool.adds(my);
        pool.adds(my);
        pool.adds(my);
        pool.adds(my);

    }

}