线程

/*
 *     注线程：执行主(main)方法的线程
 *     
 *     单线程程序：java程序中只有一个线程执行从main方法开始，从上到下依次执行
 * 
 * 
 * jvm执行main方法，main方法会进入到栈内存
 * jvm会找操作系统开辟一条mian方法向cpu的执行路径
 * cpu就可以通过这个路径来执行main方法
 * 而这个路径有个名字叫做：主线程
 * 
 * 
 *缺点：
 *    中途如果报了异常
 *    下一个进程就不会运行
 * 
 * 
 */
public class Demo01MainThread {
    public static void main(String[] args){
        Person p1 = new Person("小明");
        p1.run();
        
        System.out.println(0/0);
        
        Person p2 = new Person("小强");
        p2.run();
    }






public class Person {

    private String name;
    
    public void run(){
        //定义循环，执行20次
        for(int i=0;i<20;i++){
            System.out.println(name+i);        
        }
    }

    public Person() {
    }

    public Person(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

创建多线程的第一种方式:

/*
 *     创建多线程程序的第一种方式：创建Thread的子类
 *     java.lang.Thread类：是描述线程的类，我们箱套实现，多线程程序，就必须继承Thread类
 * 
 * 实现步骤：
 *         1、创建一个Thread类的子类
 *         2、在Thread类的子类中重写Thread类中的run方法。设置线程任务（开启线程要做什么？）
 *         3、创建Thread的子类对象
 *         4、调用Thread类中的方法start方法，开启新的线程，执行run方法
 *             void start()使线程开始执行:java虚拟机调用该线程的run方法
 *             结果是俩个线程并发地运行，当主线程和另一个线程（创建的新线程，执行其run方法）
 *             多次启动一个线程是非法的，特别是线程已经结束之后，不能再重新启动
 *     java属于抢占式调度，哪个线程的优先级高，哪个线程就会优先执行，同一个优先级，随机选则一个执行
 * 
 */
public class Demo01Thread {
    public static void main(String[] args){
            //创建Thread子类对象
            MyThread mt = new MyThread();
            //4、调用Thread类中的方法start方法，开启新的线程，执行run方法
    
            mt.start();
            
            for(int i=0;i<20;i++){
                System.out.println("main"+i);
            }            
        }
}






//    1、创建一个Thread类的子类
public class MyThread extends Thread{

    //2、在Thread类的子类中重写Thread类中的run方法。设置线程任务（开启线程要做什么？）
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println("run"+i);
        }
    
    }
    
}

Thread类的常用方法和获取线程名称：

自定义线程类：
/*
 *     获取线程的名称：
 *         1、使用Thread类中的方法getName()
 *             String getName()返回该线程的名称
 *         2、可以获取当前正在执行的线程，使用线程中的方法gerName()获取线程名称
 *             static Thread currentThread()返回对当前正在执行的线程对象的引用。
 * 
 */
//定义一个Thread类的子类
public class MyThread extends Thread {

    @Override
    public void run() {
        //获取线程的名称 
        
//        String name = getName();
//        System.out.println(name);
        
//        Thread t=Thread.currentThread();
//        System.out.println(t);//获取当前执行的线程    Thread[Thread-0,5,main]
//        String name = t.getName();
//        System.out.println(name);//可以缩短为一行
        
        
        //链式编程
        System.out.println(Thread.currentThread().getName());
        
        
        
    }
    //重写Thread类中的run方法，设置线程任务
        
}




测试类：
/*    线程的名称：
 *             主线程：main
 *             新线程：Thread-0、Thread-1、Thread-2、、、
 * 
 */
public class Demo01GetThreadName {

    public static void main(String[] args) {
        // 创建Thread的子类对象
        MyThread mt = new MyThread();
        //调用start方法，开启新线程执行run方法
        mt.start();
        new MyThread().start();
        
        //链式编程   这是获取主线程
                System.out.println(Thread.currentThread().getName());
    }

}

 设置线程的名称

了解

package com.learn.Thread04;
/*
 * 设置线程的名称：(了解)
 *         1、使用Thread类中的方法setName（名字）
 *             void setName(String name) 改变线程名称，使之与参数name相同。
 *         2、创建一个带参数的构造方法，参数传递线程名称，调用父类的带参构造方法，把线程名称传递给父类Thread给子线程起名字
 *             Thread(String name)分配新的Thread对象
 */
public class MyThread extends Thread{

    @Override
    public void run() {
        //获取线程名称进行输出
        System.out.println(Thread.currentThread().getName());
    }
    public MyThread(){}
    public MyThread(String name){
        super( name);//线程名称传递给父类Thread给子线程起名字
    }
    
    
}




//测试类

public class Demo01SetThreadName {

    public static void main(String[] args) {
        // 开启多线程
        MyThread mt = new MyThread();
        mt.setName("小强");//第一种方式设置线程名称
        mt.start();
                
        new MyThread("旺财").start();

    }

}

 Thread的sleep方法：

 * Sleep方法
 * public static void sleep(long millis);使用当前正在执行的线程以指定的毫秒数暂时停止执行
 * 毫秒数结束后，线程继续执行+
 * 
 */
public class Demo01Sleep {

    public static void main(String[] args) {
        // 模拟秒表
        for(int i=1;i<=60;i++){
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

创建线程的第二种方式：

/*
 *     1、创建一个Runable接口的实现类
 */
public class RunnableImpl implements Runnable{
//2、在实现类中重写Runnable接口中的run方法，设置线程任务
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

}




/*
 * 创建多线程程序的第二种方式：实现Runable接口
 * java.lang.Runable
 *             Runable：接口应该由那些打算通过某一线程执行其实列类来实现。类必须定义一个run的无参方法
 * java.lang.Thread类的构造方法
 *             Thread(Runable target) 分配新的Thread 对象。
 *             Thread(Runable target,String name)分配新的Thread对象
 * 实现步骤：
 *     1、创建一个Runable接口的实现类
 *     2、在实现类中重写Runable接口中的run方法，设置线程任务
 *     3、创建一个Runable接口的实现类对象
 *     4、创建Thread类对象，构造方法中传递Runable接口的实现类对象
 *     5、调用Thread类中的Star方法，开启新的线程执行run方法
 * 
 */
public class Demo01Runnable {
    public static void main (String[] args){
        
        //3、创建一个Runable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //    4、创建Thread类对象，构造方法中传递Runable接口的实现类对象
        Thread t = new Thread(run);
        t.start();
        
        for(int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

}

* 实现Runable接口创建多线程的好处：

 *         实现Runable接口创建多线程的好处：
 *         1、避免了单继承的局限性
 *             一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread类，就不能继承其他类
 *             实现了Runnable接口，还可以继承其他类，实现其他接口
 *         2、增强了程序的扩展性，降低了程序的耦合性（解耦）
 *             实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）
 *             实现类中，重写了run方法，用来设置线程任务
 *             创建Thread类对象调用star方法，用来开启新的线程
 * 
 * 
 * 传递不同的实现类开启不同的任务

匿名内部类的方式：

/*
 * 匿名内部类方式，实现线程的创建
 * 
 * 匿名：没名字
 * 
 * 内部类：写在其他类的内部
 * 
 * 匿名内部类作用：简化代码
 *         把子类继承父类，重写父类的方法创建子类对象合一部完成
 *         把实现类实现接口，重写接口中的方法，创建实现类对象和成一部完成
 * 匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
 * 
 * 格式：
 *         new 父类/接口(){
 *             重写父类/接口中的方法
 *             
 *             };
 * 
 */
public class Demo01InnerClassThread {
    public static void main(String[] args){
        //线程的父类是Thread
        //new MyThread().star()
        
        new Thread(){
            
            //重写run方法，设置线程任务
            @Override
            public void run() {
                for(int i=0;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
            
        }.start();
        //先后才能的接口Runnable
        //Runnable r = new Runnable();//多肽
        Runnable r=new Runnable(){

            @Override
            public void run() {
                // TODO Auto-generated method stub
                for(int i=0;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
                }
            }
            
        };
    Thread t = new Thread(r);
    t.start();
        //简化接口的方式
    new Thread(new Runnable(){

        @Override
        public void run() {
            // TODO Auto-generated method stub
            for(int i=0;i<20;i++){
                System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
            }
        }
        
    }).start();
        
        
    }
}