线程

---恢复内容开始---

线程：继承Thread类，重写run()方法，调用start()方法。

public class FirstThread extends Thread{
    @Override
    public void run() {
        int i=0;
        while(i<30)
            System.out.println("i:"+i++);
    }
    public static void main(String[] args) {
        FirstThread f=new FirstThread();
        f.start();
    }
}

内部类写法

public class TestThread{
public static void main(String[] args) {
    new Thread() {
        public void run() {
            System.out.println("haha");
        }
    }.start();
}
}
这里为什么调用start()方法，而不直接调用run()方法呢，用到了模板模式（template）：父类实现算法，子类实现细节；

abstract class Diagram{
    protected  char c;
    public Diagram(char c){
        this.c=c;
    }
    abstract protected void print(int size);
    abstract protected void printContent(String msg);//因为我们不想让调用者关注到我们实现的细节，这也是面向对象思想封装的一个体现；
    public final void display(String msg){//定义成不可继承是因为一旦确定就不能修改修改也只能是算法的所有者修改，如果调用者都可以通过继承修改，那算法就没有严谨性

　　　 int len=msg.getBytes().length;
        print(len);
        printContent(msg);
        print(len);
    }
}
class StarDiagram extends Diagram{
    public StarDiagram(char c){
        super(c);
    }

    @Override
    protected void print(int size) {
        for(int i=0;i<size+2;i++){
            System.out.print(c);
        }
        System.out.println();
    }

    @Override
    protected void printContent(String msg) {
        System.out.println("*");
        System.out.println(msg);
        System.out.println("*");
    }
}
public class TemplateTest {
    public static void main(String[] args) {
        Diagram d1=new StarDiagram('c');
        d1.display("heluwei");
    }
}

实现Runnable接口

class  MyThread5 implements Runnable{
    @Override
    public void run() {
        System.out.println("ha");
    }
}
public class TestThread{
public static void main(String[] args) {
    MyThread5 m=new MyThread5();
    Thread t=new Thread(m);
    t.start();
}
}

匿名内部类的写法：

public class TestThread{
public static void main(String[] args) {
    new Thread(new Runnable() {
        public void run() {
            System.out.println("ha");
        }
    }).start();
}
}

线程间状态切换：

单例模式

　　饿汉式：

　　　　　　将类的静态实例作为该类的一个成员变量，就是在JVM加载的时候就已经创建了该类的实例，所以不会存在多线程的安全问题

public class SingleTest {
private final static SingleTest instance=new SingleTest();
private SingleTest(){}
public static SingleTest newInstance(){
    return instance;
}
}

但会造成性能消耗问题；

　　懒汉式：

public class SingleTest {
private  static SingleTest instance=null;
private SingleTest(){}
public static SingleTest newInstance(){
    if(null==instance){
        instance=new SingleTest();
    }
        return instance;
    }
}

会造成线程不安全问题。判断没有，当两个线程同时到达  instance=new SingleTest();会实例化两个；

所以就用synchronized

public synchronized static SingleTest newInstance(){
    if(null==instance){
        instance=new SingleTest();
    }
        return instance;
    }

每次调用都要判断锁，解决了安全问题，但是没有解决效率问题；

public static SingleTest newInstance(){
    if(null==instance){
        synchronized(SingleTest.class){
            if(null==instance){
                instance=new SingleTest();
            }
        }
    }
    return instance;
    }

 

 

 

 

 

 

 

---恢复内容结束---