多线程(多线程实现方式二【Runnable接口实现】)

2021年9月10日 4点热度 0条评论 来源: ztgzqn

Runnable接口实现多线程

package Day23;
//多线称实现方式2()----Runnable【接口】
public class RunnableDemo implements Runnable {
    //重写此接口的run方法
    @Override
    public void run() {
        for(int x=0;x<100;x++){
        //public static Thread currentThread()返回对当前正在执行的线程对象的引用---返回当前执行的线程对象
        //获取当前线程对象的名称---Thread.currentThread.getName
            System.out.println(Thread.currentThread().getName());
        }
    }
}

测试类

package Day23;
/*
* /*
 * 方式2:实现Runnable接口
 * 步骤:
 *         A:自定义类MyRunnable实现Runnable接口
 *         B:重写run()方法
 *         C:创建MyRunnable类的对象
 *         D:创建Thread类的对象,并把C步骤的对象作为构造参数传递
 */
public class RunnableTest {
    public static void main(String[] args) {
        //创建RunnableTest对象
        RunnableDemo rbt = new RunnableDemo();

        //public Thread(Runnable target,String name)分配新的 Thread 对象。
        //target - 其 run 方法被调用的对象。
        //name - 新线程的名称。
        Thread td = new Thread( rbt,"大海");
        Thread td1= new Thread(rbt,"长江");

        //使线程开始执行---虚拟机调用此方法
        td.start();
        td1.start();

    }
}

 

  继承类Thread--实现卖电影票

package cn.itcast_06;

public class SellTicket extends Thread {

    // 定义100张票
    // private int tickets = 100;
    // 为了让多个线程对象共享这100张票,我们其实应该用静态修饰
    private static int tickets = 100;

    @Override
    public void run() {
        // 定义100张票
        // 每个线程进来都会走这里,这样的话,每个线程对象相当于买的是自己的那100张票,这不合理,所以应该定义到外面
        // int tickets = 100;

        // 是为了模拟一直有票
        while (true) {
            if (tickets > 0) {
                System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
            }
        }
    }
}
package cn.itcast_06;

/*
 * 某电影院目前正在上映贺岁大片(红高粱,少林寺传奇藏经阁),共有100张票,而它有3个售票窗口售票,请设计一个程序模拟该电影院售票。
 * 继承Thread类来实现。
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建三个线程对象
        SellTicket st1 = new SellTicket();
        SellTicket st2 = new SellTicket();
        SellTicket st3 = new SellTicket();

        // 给线程对象起名字
        st1.setName("窗口1");
        st2.setName("窗口2");
        st3.setName("窗口3");

        // 启动线程
        st1.start();
        st2.start();
        st3.start();
    }
}

 

利用Runnable接口实现电影票的售票

package Day23;
//使用Runnable接口实现电影票的销售----3个窗口
public class Movie implements Runnable {
    //定义100张电影票
    private int ticket =100;
    //重写Runnable接口的run方法

    @Override
    public void run() {
        while(true){
            if (ticket>0){
                //Runnable接口不能直接调用getName方法需要通过获取当前线程来获取名称
                System.out.println(Thread.currentThread().getName()+"正在销售第"
                +(ticket--)+"张电影票");
            }
        }
    }
}

 

package Day23;
//实现Runnable接口的多线程
public class MovieDemo {
    public static void main(String[] args) {
        //创建资源对象
        Movie m = new Movie();

        //创建三个线程对象
        //给出运行的对象---并给出线程名称
        Thread m1 = new Thread(m,"窗口1");
        Thread m2 = new Thread(m,"窗口2");
        Thread m3 = new Thread(m,"窗口3");

        //启动线程
        m1.start();
        m2.start();
        m3.start();

    }
}

 

解决线程安全问题----解决卖电影票程序问题

* 同步代码块:
* synchronized(对象){
* 需要同步的代码;
* }

package cn.itcast_09;

public class SellTicket implements Runnable {
    // 定义100张票
    private int tickets = 100;
    //创建锁对象
    private Object obj = new Object();

//    @Override
//    public void run() {
//        while (true) {
//            synchronized(new Object()){
//                if (tickets > 0) {
//                    try {
//                        Thread.sleep(100); 
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName() + "正在出售第"
//                            + (tickets--) + "张票");
//                }
//            }
//        }
//    }
    
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + "正在出售第" + (tickets--) + "张票");
                }
            }
        }
    }
}

 

测试

package cn.itcast_09;

/*
 * 如何解决线程安全问题呢?
 * 
 * 要想解决问题,就要知道哪些原因会导致出问题:(而且这些原因也是以后我们判断一个程序是否会有线程安全问题的标准)
 * A:是否是多线程环境
 * B:是否有共享数据
 * C:是否有多条语句操作共享数据
 * 
 * 我们来回想一下我们的程序有没有上面的问题呢?
 * A:是否是多线程环境    是
 * B:是否有共享数据    是
 * C:是否有多条语句操作共享数据    是
 * 
 * 由此可见我们的程序出现问题是正常的,因为它满足出问题的条件。
 * 接下来才是我们要想想如何解决问题呢?
 * A和B的问题我们改变不了,我们只能想办法去把C改变一下。
 * 思想:
 *         把多条语句操作共享数据的代码给包成一个整体,让某个线程在执行的时候,别人不能来执行。
 * 问题是我们不知道怎么包啊?其实我也不知道,但是Java给我们提供了:同步机制。
 * 
 * 同步代码块:
 *         synchronized(对象){
 *             需要同步的代码;
 *         }
 * 
 *         A:对象是什么呢?
 *             我们可以随便创建一个对象试试。
 *         B:需要同步的代码是哪些呢?
 *             把多条语句操作共享数据的代码的部分给包起来
 * 
 *         注意:
 *             同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
 *             多个线程必须是同一把锁。
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();

        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

 

同步的特点:
* 前提:
*             多个线程
* 解决问题的时候要注意:
*            多个线程使用的是同一个锁对象
* 同步的好处
*           同步的出现解决了多线程的安全问题。
* 同步的弊端
*           当线程相当多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率。

 

同步代码块的锁以及同步方法应用和锁的问题

package cn.itcast_11;

public class SellTicket implements Runnable {

    // 定义100张票
    private static int tickets = 100;

    // 定义同一把锁
    private Object obj = new Object();
    private Demo d = new Demo();

    private int x = 0;
    
    //同步代码块用obj做锁
//    @Override
//    public void run() {
//        while (true) {
//            synchronized (obj) {
//                if (tickets > 0) {
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()
//                            + "正在出售第" + (tickets--) + "张票 ");
//                }
//            }
//        }
//    }
    
    //同步代码块用任意对象做锁
//    @Override
//    public void run() {
//        while (true) {
//            synchronized (d) {
//                if (tickets > 0) {
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()
//                            + "正在出售第" + (tickets--) + "张票 ");
//                }
//            }
//        }
//    }
    
    @Override
    public void run() {
        while (true) {
            if(x%2==0){
                synchronized (SellTicket.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()
                                + "正在出售第" + (tickets--) + "张票 ");
                    }
                }
            }else {
//                synchronized (d) {
//                    if (tickets > 0) {
//                        try {
//                            Thread.sleep(100);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName()
//                                + "正在出售第" + (tickets--) + "张票 ");
//                    }
//                }
                
                sellTicket();
                
            }
            x++;
        }
    }

//    private void sellTicket() {
//        synchronized (d) {
//            if (tickets > 0) {
//            try {
//                    Thread.sleep(100);
//            } catch (InterruptedException e) {
//                    e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()
//                        + "正在出售第" + (tickets--) + "张票 ");
//            }
//        }
//    }
    
    //如果一个方法一进去就看到了代码被同步了,那么我就再想能不能把这个同步加在方法上呢?
//     private synchronized void sellTicket() {
//            if (tickets > 0) {
//            try {
//                    Thread.sleep(100);
//            } catch (InterruptedException e) {
//                    e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()
//                        + "正在出售第" + (tickets--) + "张票 ");
//            }
//    }
    
    private static synchronized void sellTicket() {
        if (tickets > 0) {
        try {
                Thread.sleep(100);
        } catch (InterruptedException e) {
                e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
                    + "正在出售第" + (tickets--) + "张票 ");
        }
}
}

class Demo {
}

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

* B:同步方法的格式及锁对象问题?
* 把同步关键字加在方法上。
* 同步方法是谁呢?
* this----本类

package Day23;
//使用Runnable接口实现电影票的销售----3个窗口

/*
*  * 同步代码块:
 *         synchronized(对象){
 *             需要同步的代码;
* */
public class Movie implements Runnable {
    //定义100张电影票
    private int ticket =100;
    //定义一个锁对象
    private Object obj = new Object();

    private int x =0;
    //重写Runnable接口的run方法

    @Override
    public void run() {
        while(true) {
            if (x % 2 == 0) {
                synchronized (this) {
                    if (ticket > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //Runnable接口不能直接调用getName方法需要通过获取当前线程来获取名称
                        System.out.println(Thread.currentThread().getName() + "正在销售第"
                                + (ticket--) + "张电影票");
                    }
                }
            } else {
                sellTicket();
            }
            x++;
        }

    }
    private synchronized void sellTicket() {
            if (ticket > 0) {
            try {
                    Thread.sleep(100);
            } catch (InterruptedException e) {
                    e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()
                        + "正在出售第" + (ticket--) + "张票 ");
            }
    }
}

 

测试类

package Day23;
//实现Runnable接口的多线程
public class MovieDemo {
    public static void main(String[] args) {
        //创建资源对象
        Movie m = new Movie();

        //创建三个线程对象
        //给出运行的对象---并给出线程名称
        Thread m1 = new Thread(m,"窗口1");
        Thread m2 = new Thread(m,"窗口2");
        Thread m3 = new Thread(m,"窗口3");

        //启动线程
        m1.start();
        m2.start();
        m3.start();

    }
}

 

 

 

 

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

/*
* A:同步代码块的锁对象是谁呢?
* 任意对象。
*
* B:同步方法的格式及锁对象问题?
* 把同步关键字加在方法上
*
* 同步方法是谁呢?
* this----本类
*
* C:静态方法及锁对象问题?
* 静态方法的锁对象是谁呢?
* 类的字节码文件对象。(反射会讲)
*/

package cn.itcast_11;

/*
 * A:同步代码块的锁对象是谁呢?
 *         任意对象。
 * 
 * B:同步方法的格式及锁对象问题?
 *         把同步关键字加在方法上。
 * 
 *         同步方法是谁呢?
 *             this
 * 
 * C:静态方法及锁对象问题?
 *         静态方法的锁对象是谁呢?
 *             类的字节码文件对象。(反射会讲)
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();

        // 创建三个线程对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

 

以前线程安全类回顾

package cn.itcast_12;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;

public class ThreadDemo {
    public static void main(String[] args) {
        // 线程安全的类
        StringBuffer sb = new StringBuffer();
        Vector<String> v = new Vector<String>();
        Hashtable<String, String> h = new Hashtable<String, String>();

        // Vector是线程安全的时候才去考虑使用的,但是我还说过即使要安全,我也不用你
        // 那么到底用谁呢?
        //Collections
        //public static <T> List<T> synchronizedList(List<T> list)返回指定列表支持的同步(线程安全的)列表
        List<String> list1 = new ArrayList<String>();// 线程不安全
        List<String> list2 = Collections
                .synchronizedList(new ArrayList<String>()); // 线程安全
    }
}

 

    原文作者:ztgzqn
    原文地址: https://www.cnblogs.com/ztg-java-xuexi/p/16100960.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。