多线程的几种写法 和 三个窗口同时卖票 用 实现Runnable方式

并发与并行

并行: 指两个或多个事件在同一时刻发生 ( 同时发生 ) 。

并发: 指两个或多个事件在同一个时间段内发生。

多线程使用场景:

1. 后台任务,比如游戏服务器

2.定时向大量用户(100W)用户发邮件

3.异步处理: 发微博/记录日志等

4.分布式计算...

线程和进程区别

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多 个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位;系统运行一个程序即是一个进程从创 建、运行到消亡的过程。

线程:进程内部的一个独立执行单元;一个进程可以同时并发的运行多个线程，可以理解为一个进程便相当 于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。

synchronized是Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。

当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍可以访问该object中的非加锁代码块
被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。

synchronized是实现线程同步的关键字，可以说在并发控制中是必不可少的部分

三个窗口同时卖票 用 实现Runnable方式

 接口 Runnable 重写run方法 没有返回值 

public class ticketRunnable implements Runnable{
    static Object obj=new Object();
    static int count=1;
    @Override
    public void run() {
        while (true){

            try {
                Thread.sleep(1000);
                synchronized (obj) {
                    if (count<=100) {
                        System.out.println(Thread.currentThread().getName() + "出票 编号为" + (count++));
                    }else {
                        System.out.println("卖完了");
                        System.exit(0);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        ticketRunnable ti=new ticketRunnable();
        Thread th1=new Thread(ti,"第一窗口");
//        th1.setName("第一窗口");
        th1.start();
        Thread th2=new Thread(ti,"第二窗口");
        th2.start();
        Thread th3=new Thread(ti,"第三窗口");
        th3.start();
    }
}

继承Thread类 

public class MyThread extends Thread{
    static Object obj=new Object();
    static int count=1;
    @Override
    public void run() {
            while (true){

                try {
                    Thread.sleep(1000);
                    synchronized (obj) {
                    if (count<=100) {
                        System.out.println(Thread.currentThread().getName() + "打印的第" + (count++) + "次");
                    }else {
                        System.out.println("打完了");
                        System.exit(0);
                    }
                }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        }
    }

    public static void main(String[] args) {
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        my1.setName("1号");
        my2.setName("2号");
        my1.start();
        my2.start();
    }
}

自定义类 实现Runnable接口类，重写run方法，没有返回值

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

自定义类 实现callable接口 有返回值

 

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i=0;
        for (; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        return i;
    }

    public static void main(String[] args) {
        CallableDemo ca=new CallableDemo();
        FutureTask<Integer> ft=new FutureTask<>(ca);
        for (int i = 0; i < 20; i++) {
            System.out.println("当前执行到"+i);
        }
        try {
            Integer in= ft.get();
            System.out.println(in);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}