甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
一、操作系统中线程和进程的概念
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名申请、网站空间、营销软件、网站建设、鹤岗网站维护、网站推广。
现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。
线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。
“同时”执行是人的感觉，在线程之间实际上轮换执行。
二、Java中的线程
在Java中，“线程”指两件不同的事情：
1、java.lang.Thread类的一个实例；
2、线程的执行。
使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。
一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。
Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。
一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。
一旦创建一个新的线程，就产生一个新的调用栈。
线程总体分两类：用户线程和守候线程。
当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的
一 操作系统中线程和进程的概念
现在的操作系统是多任务操作系统 多线程是实现多任务的一种方式
进程是指一个内存中运行的应用程序 每个进程都有自己独立的一块内存空间 一个进程中可以启动多个线程 比如在Windows系统中 一个运行的exe就是一个进程 线程是指进程中的一个执行流程 一个进程中可以运行多个线程 比如java exe进程中可以运行很多线程 线程总是属于某个进程 进程中的多个线程共享进程的内存 同时 执行是人的感觉 在线程之间实际上轮换执行
二 Java中的线程
在Java中 线程 指两件不同的事情
java lang Thread类的一个实例
线程的执行
使用java lang Thread类或者java lang Runnable接口编写代码来定义 实例化和启动新线程 一个Thread类实例只是一个对象 像Java中的任何其他对象一样 具有变量和方法 生死于堆上 Java中 每个线程都有一个调用栈 即使不在程序中创建任何新的线程 线程也在后台运行着 一个Java应用总是从main()方法开始运行 mian()方法运行在一个线程内 它被称为主线程 一旦创建一个新的线程 就产生一个新的调用栈 线程总体分两类 用户线程和守候线程
当所有用户线程执行完毕的时候 JVM自动关闭 但是守候线程却不独立于JVM 守候线程一般是由操作系统或者用户自己创建的
———————————MultiT java——————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//mt setDaemon(true);//设定为后台线程 main进程结束时 后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY); //设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后 程序运行时 mt线程一直运行 强制终止时 main线程才运行
//设定为最高优先级的线程 无论有无yield(); 线程总一直运行 直到强制终止时 main和mt线程交替运行
mt start();
int index= ;
while(true) //显示结果与教程不同
{
if(index++== )
break;
System out println( main: +Thread currentThread() getName()); //获取线程名字
}
}
}
class MyThread extends Thread
{
public void run()
{
while(true)
{
System out println(getName());
yield(); //允许当前线程停止 转去执行其他线程 静态方法
//mt进程执行时 切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后 返回到main进程
}
}
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度 从而运行
//打破高优先级线程始终获有运行时间的状态
——————————————————————————————————————
——————————MultiThread java———————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//new Thread(mt) start(); //创建多个同样的线程访问同一个变量index 若MyThread采用继承Thread方式 则无法共享同一个变量
//new Thread(mt) start();
//new Thread(mt) start();
//new Thread(mt) start();
mt getThread() start(); //也可以采用内部类的方式共享访问同一个变量
mt getThread() start();
mt getThread() start();
mt getThread() start();
//mt setDaemon(true);//设定为后台线程 main进程结束时 后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY); //设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后 程序运行时 mt线程一直运行 强制终止时 main线程才运行
//设定为最高优先级的线程 无论有无yield(); 线程总一直运行 直到强制终止时 main和mt线程交替运行
//mt start();
int index= ;
while(true) //显示结果与教程不同
{
// if(index++== )
// break;
System out println( main: +Thread currentThread() getName()); //获取线程名字
}
}
}
class MyThread //implements Runnable //extends Thread //使用外部类的方式
//使用内部类完成使用Runnable接口才能完成的两个功能 a 创建多个线程 b 访问同一个变量
{
int index= ;
private class InnerThread extends Thread //不想让外部访问其实现方法 加上private
{
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+ : +index++);
}
}
}
Thread getThread()
{
return new InnerThread();
}
/*
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+ : +index++);
//yield(); //允许当前线程停止 转去执行其他线程 静态方法
//mt进程执行时 切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后 返回到main进程
}
}
*/
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度 从而运行
//打破高优先级线程始终获有运行时间的状态
//如果不需要修改Thread类的除了run方法外的其他方法 选用implements Runnable
———————————————————————————————————————
———————————TicketsSystem java———————————————————
//多线程实现火车票的售票系统 用同步块 或著同步方法
class TicketsSystem
{
public static void main(String[] args) //运行结果与教程中不同 不完全顺序 每次运行 顺序都不完全一样
{
SellThread st=new SellThread();//创建四个线程访问同一变量tickets
// 错 SellThread st =new SellThread();//若采用创建四个对象的方式 则每个对象中都有 张票
new Thread(st) start(); //b为false 用的同步方法 | //同步方法与同步块共用中 显示的是只调用了同步块 而同步方法未被调用
//b为true 用的同步块 | //原因 启动第一个线程后 CPU时间片没有到期 线程没有立即运行 接着执行b=true
// | //解决办法 启动第一个线程后 执行一个睡眠时间 让CPU时间片到期
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
st b=true;
new Thread(st) start();
//new Thread(st) start();
//new Thread(st) start();
}
}
class SellThread implements Runnable //程序有点小问题 当剩下最后一张票时 四个线程都运行 可能会出现票数为 （系统长时间运行时）
//可加上一个静态方法sleep();它会抛出异常
{
int tickets= ;
//Object obj=new Object();//也可以声明一个Thread对象
Thread th=new Thread();
boolean b=false;
public void run()
{
if(b==false)
{
while(true)
sell();
}
else
{
while(true)
{ //同步方法利用的是this所代表的对象的锁
synchronized(this) //采用同步后 显示正确 此方法两步 声明Thread对象 用synchronized把原方法括起来
{ //这里换th为this
///*
if(tickets )
{
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
System out println( th +Thread currentThread() getName()+ sell tickets: +tickets);
tickets ;
}
//*/
}
}
}
}
public synchronized void sell() //每个class也有一个锁 是这个class所对应的class对象的锁（监视器）
{
if(tickets )
{
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
System out println( sell +Thread currentThread() getName()+ sell tickets: +tickets);
tickets ;
}
}
}
————————————————————————————————————————
———————————TestWN java————————————————————
class Test
{
public static void main(String[] args)
{
Queue q=new Queue();
Producer p=new Producer(q);
Consumer c=new Consumer(q);
p start();
c start();
}
}
class Producer extends Thread
{
Queue q;
Producer(Queue q)
{
this q=q;
}
public void run()
{
for(int i= ;i ;i++)
{
q put(i);
System out println( Producer put: +i);
}
}
}
class Consumer extends Thread
{
Queue q;
Consumer(Queue q)
{
this q=q;
}
public void run()
{
while(true)
{
System out println( Consumer get: +q get());
}
}
}
class Queue //wait notify 方法必须用在同步方法中 要加上关键字synchronized
{
int value;
boolean bFull=false;
public synchronized void put(int i)
{
if(!bFull)
{
value=i;
bFull=true;
notify();
}
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
public synchronized int get()
{
if(!bFull)
{
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
bFull=false;
notify();
return value;
}
}
————————————————————————————————————
————————————TestThread java———————————————————————
class TestThread
{
public static void main(String[] args)
{
Thread t =new Thread ();
t start();
int index= ;
while(true)
{
if(index++== )
{
t stopThread();
t interrupt(); //让线程 终止
break;
}
System out println(Thread currentThread() getName());
}
System out println( main() exit );
}
}
class Thread extends Thread
{
private boolean bStop=false;
public synchronized void run()
{
while(!bStop)
{
try
{
wait(); //加入wait后 main线程结束时 程序还未终止 原因是Thread 的线程调用wait方法 进入对象的等待队列中 需要notify方法将它唤醒
}
catch(Exception e)
{
//e printStackTrace();
if(bStop)
return;
}
System out println(getName());
}
}
public void stopThread()
{
bStop=true;
}
}
lishixinzhi/Article/program/Java/gj/201311/27407
多线程：指的是这个程序（一个进程）运行时产生了不止一个线程
并行与并发：
并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。
线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果，如不加事务的转账代码：
请点击输入图片描述
同步：Java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时，提高性能，才是优秀的程序。线程安全的优先级高于性能。
在计算机中当一个程序运行的时候就会创建至少一个进程，例如当我们运行QQ的时候，系统就会创建进程来处理我们平时的一些操作，当我们打开任务管理器的时候，在进程的列表里面就可以找到QQ.exe的运行程序;
在计算机中处理进程之外还有另一个概念就是线程，线程是存在于进程当中，一个进程可以包含多个线程;当我们的计算机有多核处理器的时候，使用多线程可以加快程序的运算速率;如果一个进程中只有一个线程，当程序遇到一个比较耗时的计算的时候，由于程序是单线程的，那么程序只能等待这个运算结束的时候再继续运行，这样会大大的降低程序的效率;当时用多个线程的时候，在某个线程遇到比较耗时的运算的时候，该线程可以继续自己的运算，但是其他的线程也可以同步进行，这样当耗时的计算结束之后，其他线程也将自己所需要的东西执行完毕，这样就会很大的提高程序执行效率;
在程序运行中对于文件的保存相对于处理器的运算速度来说是很慢的，当我们程序中接收到一个保存文件的信息之后，我们可以创建一个保存文件的线程，在主线程中我们可以继续进行我们的其他运算，这样当文件保存好之后，我们的其他运算也会完成，互不影响;
在Java中我们可以创建一个自己的类继承于Thread类，并且重写run() 方法，当线程启动之后，run()方法里面的操作都在线程中进行处理，而不会影响主线程的信息;
当我们创建好一个自定义线程类之后，我们可以创建这个自定义线程的对象，进行线程的启动;线程须调用start();方法进行启动，这样run()方法里面的内容才会在线程中运行;如果我们不去调用start()方法，那我们只是创建了一个普通的类，即使我们手动调用run()方法，run()方法里面的内容也不会在线程中运行;
在Java中线程主要有初始状态，运行状态，阻塞状态，终止状态等;当我们新创建一个线程对象的时候，此时线程的状态为初始状态;当我们调用start()之后，此时的线程才被激活成为运行状态，之后run()方法里面的信息才会在子线程中运行;我们可以在不同的阶段调用不同的方法将线程设置为不同的状态;比如有时候我们的操作需要等待其他线程中运算结束之后才可以继续进行，这时候我们就可以将线程设置为等待状态，当需要的资源满足条件之后，可以继续运行当前的线程;
package threadgroup;
class ThreadDemo3 extends Thread {
private String name;
private int delay;
public ThreadDemo3(String sname, int i_delay) {
name = sname;
delay = i_delay;
}
public void run() {
try {
sleep(delay);
} catch (InterruptedException e) {
}
System.out.println("多线程测试！\n" + name + "\n" + delay);
}
}
public class testMyThread {
public static void main(String[] args) {
ThreadDemo3 th1,th2,th3;
th1 = new ThreadDemo3("线程1", (int) (Math.random() * 900));
th2 = new ThreadDemo3("线程2", (int) (Math.random() * 900));
th3 = new ThreadDemo3("线程3", (int) (Math.random() * 900));
th1.start();
th2.start();
th3.start();
}
}
package threadgroup;
public class threadDemo {
public static void main(String[] args) {
Thread t = Thread.currentThread();
t.setName("你好吗？");
System.out.println("正在进行的Thread是：" + t);
try {
for (int i = 0; i 5; i++) {
System.out.println("我不叫穆继超" + i);
Thread.sleep(3000);
}
} catch (Exception e) {
// TODO: handle exception
System.out.println("Thread has wrong" + e.getMessage());
}
}
}
package threadgroup;
public class threadDemo2 implements Runnable {
public threadDemo2() {
Thread t1 = Thread.currentThread();
t1.setName("第一个主进程");
System.out.println("正在运行" + t1);
Thread t2 = new Thread(this, "");
System.out.println("在创建一个进程");
t2.start();
try {
System.out.println("使他进入第一个睡眠状态");
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println("Thread has wrong" + e.getMessage());
}
System.out.println("退出第一个进程");
}
public void run() {
try {
for (int i = 0; i 5; i++) {
System.out.println("进程" + i);
Thread.sleep(3000);
}
} catch (InterruptedException e) {
// TODO: handle exception
System.out.println("Thread has wrong" + e.getMessage());
}
System.out.println("退出第二个进程");
}
public static void main(String[] args) {
new threadDemo2();
}
}
打个比方，用户注册，如果用户注册有如下步骤
1：给用户在数据库中添加用户信息
2：给用户的手机号发送欢迎短信
3：系统中其它模块和用户关联，需要同时添加其它的数据
这个时候，如果使用单线程，用户提交注册信息之后，系统拿到注册信息，就要按照步骤1,2,3这么一步一步走下去，在这过程中，用户只能等待，等到系统把这些步骤走完了，用户才能得到响应，才能登陆系统，这个过程会很长，用户体验不好
但是如果使用多线程，在拿到用户注册信息之后，主进程把这些任务分给多个线程去做，每个线程做一件事，效率是不是提高了，时间是不是缩短了，并且，主线程可以把关键信息录入系统之后就直接响应用户，其它事情可以让线程在后台慢慢执行，这样用户体验就会好很多。