Java—多线程

多线程的实现方式 一

package Test_12;
/*
 * 进程：当前正在运行的程序，一个应用程序在内存中的执行区域
 * 线程：进程中的一个执行控制单元
 * 
 * 一个进程可以有一个线程（单线程），也可以有多个线程（多线程）
 * 
 * 单线程：安全性高，效率低
 * 多线程：效率高，安全性低
 * 
 * 多线程的实现：
 *      1.一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。
 *      2.另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。
 *           然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
 * 
 * Thread类的方法：
 *      1. String getName()   返回该线程的名称。 
 *      2. void setName(String name)   改变线程名称，使之与参数 name 相同。 
 *      3. void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 
 * 
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread mt = new MyThread();
        //修改线程名
        mt.setName("线程一");
        //启动线程
        mt.start();

        //创建线程对象
        MyThread mt2 = new MyThread();
        //修改线程名
        mt2.setName("线程二");
        //启动线程
        mt2.start();
    }
}


----------

package Test_12;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}

多线程的实现方式二

package Test_12;
/*
 * 多线程的实现方式二：
 *      声明实现 Runnable 接口的类。该类然后实现 run 方法。
 *      然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
 * 
 * Thread(Runnable target) 分配新的 Thread 对象。
 * 
 * static Thread currentThread() 返回对当前正在执行的线程对象的引用。 
 * 
 * 
 * 
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建线程对象
        MyThread mt = new MyThread();
        //修改线程名
        mt.setName("线程一");
        //启动线程
        mt.start();

        //创建线程对象
        MyThread mt2 = new MyThread();
        //修改线程名
        mt2.setName("线程二");
        //启动线程
        mt2.start();
    }
}


----------

package Test_12;

public class MyThread2 implements Runnable {

    @Override
    public void run() {
        Thread tr = Thread.currentThread();
        for (int i = 0; i < 100; i++) {
            System.out.println(tr.getName()+":"+i);
        }
    }

  /*@Override
    public void run() {
        // Thread tr = Thread.currentThread();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }*/

  /*@Override
    public void run() {
        // Thread tr = new Thread();
        for (int i = 0; i < 100; i++) {
            System.out.println(new Thread().getName()+":"+i);
        }
    }*/

}

多线程模拟火车站售票

package Test_12;
/*
 * 多线程模拟火车站售票
 *      分析：
 *          1.定义火车票总量，每出售一张则总票数减一
 *          2.当总票数等于零时则停止售票
 *          3.使用多线程模拟多个售票窗口售票
 *      
 * static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。  
 * 
 * synchronized：同步（锁），可以修饰代码块和方法，被修饰的代码块和方法一旦被某个线程访问，则直接被锁住，其他的线程无法访问
 * 
 * 同步代码块：
 *          synchronized(锁对象){
 * 
 *          }
 * 注意：锁对象需要被所有的线程所共享
 * 
 * 同步方法：使用关键字synchronized修饰的方法，一旦被一个线程访问，则整个方法全部被锁住，其他线程无法访问
 * 
 * 注意：
 *      1.非静态同步方法的锁对象是this
 *      2.静态同步方法的锁对象是当前类的字节码对象
 * 
 */
public class TicketTest {
    public static void main(String[] args) {
        //创建线程对象
        TicketThread tt = new TicketThread();

        Thread tr = new Thread(tt);
        //修改线程名
        tr.setName("窗口1");
        //启动线程
        tr.start();

        Thread tr2 = new Thread(tt);
        //修改线程名
        tr2.setName("窗口2");
        //启动线程
        tr2.start();

        Thread tr3 = new Thread(tt);
        //修改线程名
        tr3.setName("窗口3");
        //启动线程
        tr3.start();
    }
}


----------

package Test_12;

public class TicketThread implements Runnable {
    int tickets = 100; //火车票总量
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            method();
        }
    }
    private synchronized void method() {
        if(tickets>0){
            try {
                Thread.sleep(100);//线程休眠100ms
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+":"+tickets--);
        }
    }

}