java中的多线程1(基本实现)

进程与线程

• 进程就是一个程序运行的时候被cpu抽象出来的，一个程序运行后被抽象为一个进程。对于操作系统来讲，一个任务就是一个进程，比如打开一个浏览器就是启动一个浏览器进程。
• 线程是一个进程里面分割出来的，由于CPU处理进程的时候是采用时间片轮转的方式，所以要把一个大个进程给分割成多个线程。
• 进程和线程的关系是：线程属于进程，线程运行在进程空间内，同一进程所产生的线程共享一个内存空间，当进程退出时，线程被强制退出并清除
• 并行与并发
  1. 并行 :多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
  2. 并发:通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。

java中的多线程

• java中实现多线程主要通过Thread类和Runnable接口实现,一个简单的售票程序：
  1. 方式一：Thread

  public class sellTicket{
  	public static void main(String [] args){
  		window window1 = new window();
      	window window2 = new window();
      	window window3 = new window();
      	
      	window1.setName("窗口1");
      	window2.setName("窗口2");
      	window3.setName("窗口3");
      	
      	window1.start();
      	window2.start();
      	window3.start();
  	}
  }
  
  class window extends Thread{
  	public static int tickets = 100;
  	@Override
  	public void run() {      
      	while(true){
          	if(tickets>0){
              	System.out.println(Thread.currentThread().getName()+":卖出第"+tickets+"张票");
              	tickets=tickets-1;
          	}else{
              	break;
          	}
      	}
  	}
  }
  

  2. 方式二：Runnable

	public class testThread{
        
    public static void main(String [] args) {
        
        window window = new window();
        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);
        
        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");
        
        thread1.start();
        thread2.start();
        thread3.start();
        
        }
    }

class window implements Runnable{
    
    int tickets = 100;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            if(tickets>0){
                System.out.println(Thread.currentThread().getName()+":卖出第"+tickets+"张票");
                tickets=tickets-1;
            }
        }
    }
}

3. 方式三
   实现Callable接口

public class TestThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask futureTask = new FutureTask(new Window());

        Thread thread = new Thread(futureTask);
        thread.start();
        // get()方法的执行会导致“当前线程阻塞”
        Object o = futureTask.get();

        System.out.println("获取到结果为："+o);

    }
}
class Window implements Callable {

    @Override
    public Object call() throws Exception {

        int a =10;
        int b = 20;
        return a+b;
    }
}

以上是三种基本的实现多线程的方式。但是上面的两种线程实现存在线程安全的问题。

• 线程安全
  同一程序中运行多个线程不会存在线程安全问题。当多个线程访问相同的资源时，就会出现问题，上面的例子中，举个特殊的例子，在tickets=1时，如果线程一进入程序，还没有执行完成tickets-1，线程二进入程序，还是得到tickets=1，假设线程一此时执行完了tickets-1，那么此时tickets=0，因为tickets资源是共享的，那么此时线程二的tickets=0，要执行tickets-1，执行完成后tickets=-1，是不符合逻辑的。这就是此程序的线程安全的问题。
  关于线程安全问题，下次介绍处理方式。