java多线程编程(二创建线程)

1、概念     

     因为java是完全面向对象的，所以在java中，我们说的线程，就是Thread类的一个实例对象。所以，一个线程就是一个对象，它有自己字段和方法。

2、创建线程

创建线程有2种方法：1、扩展线程父类Thread类 ， 2、实现Runnable接口。2种方法是由区别的。

提示：Thread类已经实现了Runnable接口，Thread类中不但实现了run方法，也定义了更多的，全面的线程对象的操作方法，而Runnable接口中只有run这一个方法。

通过扩展Thread类

public class Test  {

    public static void main(String[] args)
    {

        System.out.println("我是"+Thread.currentThread().getName()+"线程");

        MyThread t1 = new MyThread("线程1");
        MyThread t2 = new MyThread("线程2");

        t1.start();
        t2.start();

        System.out.println(Thread.currentThread().getName()+"线程运行完毕");

    }

}

class MyThread extends Thread
{

    public MyThread()
    {
        super();
    }
    public MyThread(String name)
    {
        super(name);
    }

    @Override      //重写父类的run方法
    public void run()
    {

       for(int i=0;i<5;++i)
       {
           System.out.println("我是 "+this.getName());

           try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
       }
    }

}

输出：

我是main线程
main线程运行完毕
我是 线程2
我是 线程1
我是 线程1
我是 线程2
我是 线程1
我是 线程2
我是 线程1
我是 线程2
我是 线程2
我是 线程1

总结法发现：3个线程抢占CPU资源 ，快速交替执行，谁也不等谁，他们只等CPU。

通过实现Runnable接口

public class Test  {

    public static void main(String[] args)
    {

        MyThreadTest com = new MyThreadTest();

        Thread t1 = new Thread(com,"线程1");
        Thread t2 = new Thread(com,"线程2");

        t1.start();
        t2.start();

    }

}

class MyThreadTest implements Runnable
{

    private int num = 50;
    @Override
    public  void run()
    {

       while(num>=1)
       {
           System.out.println("来自"+Thread.currentThread().getName()+" num = "+ num);
           num--;
       }

    }

}

输出：（不同的机器和运行时间会输出不同的结果）

来自线程2 num = 10
来自线程1 num = 10
来自线程2 num = 9
来自线程1 num = 8
来自线程2 num = 7
来自线程1 num = 6
来自线程2 num = 5
来自线程1 num = 4
来自线程1 num = 2
来自线程1 num = 1
来自线程2 num = 3

我们发现线程1和线程2输出的数都不是完整的从10 ~1，因为他们2个程序共同操作一个“伪线程类“MyThreadTest 的实例，就是com。所以，当线程t1把num的值改为9的时候，这个时候t2访问到的num的值就是9了。这里涉及到线程同步的问题，我还在以后的随笔中讲解。

我为什么叫MyThreadTest叫“伪线程类”？因为MyThreadTest类根本就不是一个线程类。它和Thread虽然都实现了Runnable接口，但是MyThreadTest和Thread没有继承关系，我们前面说过，java中的线程是Thread类的一个实例。好比Rectangle类和Triangle类都实现了Shape接口，难道一个三角形可以看成一个矩形吗？显然是不可以的。

所以，我们通过Runnable接口去创建线程，还是需要借助Thread类。

Thread t1 = new Thread(com);

Thread t2 = new Thread(com);

因为t1和t2在构造时，使用的同一个“伪线程类”对象com ，所以t1 t2操作的就是同一个对象com 。如果你不想这样，那就分别为t1 t2提供不同的"伪线程类"对象

　　Thread t1 = new Thread(new MyThreadTest());

Thread t2 = new Thread(new MyThreadTest());

小结

一、一般我们建议实现Runnable，虽然多写一行代码，但这样更灵活，可扩展性强。

二、自定义线程中的run方法相当于主线程中的main方法，为什么要取名为main呢？因为这是java与系统之间的约定，main是程序入口的签名，他是一个标志，当java程序启动时，就会去调用名字为main 的方法。同理，一个新线程要执行它的业务逻辑代码，也需要一个约定好的名字：run。它和其他方法没有任何区别，只不过名字特殊而已。

3、Thread类中一些常用的线程操作方法（标有*的是要重点掌握的方法）

*t.start()	使t线程进入准备状态，能有被CPU执行的权利，但不一定马上被执行
*t.run()	不要自己显示调用run方法，当CPU给某个线程执行机会时，run方法就会自动执行。
t.getName()	返回此线程的名字
t.setName(String  name)	设定线程的名字
t.setPriority(int level)	设定线程的优先级 Thread.MAX_PRIORITY  最高优先级，10 Thread.MIN_PRIORITY   最低优先级   1 Thread.NORM_PRIORITY 一般优先级 5 设置优先级后，JVM的事件调度器会根据线程的优先级来按顺序来调用线程。 通常高优先级线程会先于低优先级运行，但是这个规律不是总成立的。 优先级只会改变线程谁最先启动，和谁最后启动。CPU对每一个线程的单次执行时间片是固定的。
t.getPriority()	获取线程的优先级
*t.join()	线程合并。这句话写在哪个线程里面，就是让t1线程加入到那个线程的执行流程中。暂停执行这句话的线程，直到t1线程执行完毕后，在接着执行   。例如在main线程中有t1.join()     ，执行到这个join函数时，main线程则暂，直到t1线程执行完毕， 在回来main接着执行。
*t.isAlive()	线程是否活着
静态方法：
Thread.yield()	该线程主动放弃被CPU执行的机会，让出CPU给相同优先级的线程，自己再次进入准备状态  ，下次会接着执行。这个方法的效果一般不会太明显，因为线程放弃CPU后再次进入准备阶段，而后又获得CPU的过程会很快。
Thread.currentThread()	反回当前正在运行的线程的引用
*Thread.sleep(long millis)	让线程睡眠millis毫秒，挂起，进入阻塞状态。此时CPU就会释放对此线程，而去 执行其它的线程睡眠时间过去后，该线程再次进入准备状态，等待被CPU执行。所以millis的值是至少的暂停时间。而不是绝对的暂停时间。
未完。。。待补充