进程与线程

  • 进程就是一个程序运行的时候被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;
        	}
    	}
	}
}
  1. 方式二：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;
            }
        }
    }
}
  1. 方式三
    实现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，是不符合逻辑的。这就是此程序的线程安全的问题。
    关于线程安全问题，下次介绍处理方式。