java多线程runnable和thread的区别 面试题
runnable和thread的区别（多线程必须用Runable）
Java中有两种实现多线程的方式以及两种方式之间的区别
看到一个面试题.问两种实现多线程的方法.没事去网上找了找答案.
网上流传很广的是一个网上售票系统讲解.转发过来.已经不知道原文到底是出自哪里了.
Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？
为了回答这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的100张车票，一个售票点用一个线程表示。
首先这样编写这个程序：
Java代码
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket 》 0){
System.out.println(Thread.currentThread().getName() +
“is saling ticket“ + ticket--);
}else{
break;
}
}
}
}
源码打印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket 》 0){
System.out.println(Thread.currentThread().getName() +
“is saling ticket“ + ticket--);
}else{
break;
}
}
}
}
main测试类:
Java代码
public class ThreadDome1{
public static void main(String args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}
源码打印？
public class ThreadDome1{
public static void main(String args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}
上面的代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果 告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。
我们接着修改ThreadDemo1，在main方法中创建四个Thread对象：
Java代码
public class ThreadDemo1{
public static void main(String args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
源码打印？
public class ThreadDemo1{
public static void main(String args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
Java代码
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket 》 0){
System.out.println(Thread.currentThread().getName() +
“ is saling ticket“ + ticket--);
}else{
break;
}
}
}
}
源码打印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket 》 0){
System.out.println(Thread.currentThread().getName() +
“ is saling ticket“ + ticket--);
}else{
break;
}
}
}
}
这下达到目的了吗？
从结果上看每个票号都被打印了四次，即 四个线程各自卖各自的100张票，而不去卖共同的100张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有100张票，每个线程都在独自处理各自的资源。
经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。
Java代码
public class ThreadDemo1{
public static void main(String args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
源码打印？
public class ThreadDemo1{
public static void main(String args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
Java代码
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets 》 0){
System.out.println(Thread.currentThread().getName() +
“ is saling ticket “ + tickets--);
}
}
}
}
源码打印？
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets 》 0){
System.out.println(Thread.currentThread().getName() +
“ is saling ticket “ + tickets--);
}
}
}
}
上面的程序中，创建了四个线程， 每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。
可见， 实现Runnable接口相对于继承Thread类来说，有如下显著的好处：
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。
(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。
python多线程几种方法实现
Python进阶(二十六)-多线程实现同步的四种方式
临界资源即那些一次只能被一个线程访问的资源，典型例子就是打印机，它一次只能被一个程序用来执行打印功能，因为不能多个线程同时操作，而访问这部分资源的代码通常称之为临界区。
锁机制
threading的Lock类，用该类的acquire函数进行加锁，用realease函数进行解锁
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加锁，锁住相应的资源
self.num += 1
num = self.num
self.lock.release()#解锁，离开该资源
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#将num加1，并输出原来的数据和+1之后的数据
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使线程一个一个执行12345678910111213141516171819202122232425262728
当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“同步阻塞”（参见多线程的基本概念）。
直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。
信号量
信号量也提供acquire方法和release方法，每当调用acquire方法的时候，如果内部计数器大于0，则将其减1，如果内部计数器等于0，则会阻塞该线程，知道有线程调用了release方法将内部计数器更新到大于1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允许最多三个线程同时访问资源
def add(self):
self.sem.acquire()#内部计数器减1
self.num += 1
num = self.num
self.sem.release()#内部计数器加1
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):
在VC中，多线程如何调用类得成员函数
函数内部调用：HANDLE hThread1=CreateThread(NULL,0,Fun1Proc,(LPVOID)this,0,NULL);
HANDLE hThread0=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread,&m_prog,0,NULL);
CloseHandle(hThread0);
CloseHandle(hThread1);）
Sleep(100);
}
DWORD WINAPI ListenThreadFunc(LPVOID lpParameter)
{
CTestDlg *pDlg=(CTestDlg *)lpParameter;//把传过来的参数再强制转换回CTestDlg *类型
pDlg-》GetDlgItem(IDC_EDIT1)-》SetWindowText(“abc“);//就可以了
}
thread(CProgressCtrl *pro)//更新进度条
{
int i=0;
for(;i《100;)
{
pro-》SetPos(i);
Sleep(200);
i=i+5;
if(i》94)
i=1;
else
;
if(stopmark==1)
{
pro-》SetPos(0);
break;
}
}
return 0;
}
DWORD WINAPI Fun1Proc(LPVOID lpParameter)//调用程序
{
CCOTSDlg *pDlg=(CCOTSDlg *)lpParameter;//把传过来的参数再强制转换回CTestDlg *类型
pDlg-》Modeprocess();//就可以了
return 0;
}
控制多线程，开启、暂停、继续、终止（实例）
我们这些文盲以前一听到多线程这么几个字，以为非常的高级，难搞！！昨天翻阅了一下MSDN，发现，其实也没那么难，关键在于全面的理解，也许是用多了API了，慢慢的会看懂了一些！！！
我总结了几个易于理解的出来，一起共享！
我们先不讲如何使用线程过程中的参数；先来个简单的；下篇文章我们在讲如何使用线程过程的参数来实现交互！
AfxBeginThread 创建线程
函数原型：
CWinThread* AfxBeginThread( AFX_THREADPROC pfnThreadProc,
LPVOID pParam,
int nPriority = THREAD_PRIORITY_NORMAL,
UINT nStackSize = 0,
DWORD dwCreateFlags = 0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL
);
该函数用于创建线程；返回值类型为：CWinThread*，一个指向新线程的线程对象
参数：
pfnThreadProc
线程的入口函数,声明一定要如下: UINT MyThreadFunction( LPVOID pParam );
pParam :
传递入线程的参数,注意它的类型为:LPVOID,所以我们可以传递一个结构体入线程.
nPriority :
线程的优先级,一般设置为 0 .让它和主线程具有共同的优先级.
nStackSize :
指定新创建的线程的栈的大小.如果为 0,新创建的线程具有和主线程一样的大小的栈
dwCreateFlags :
指定创建线程以后,线程有怎么样的标志.可以指定两个值:
CREATE_SUSPENDED :
线程创建以后,会处于挂起状态,直到调用:ResumeThread
0 :
创建线程后就开始运行.
lpSecurityAttrs :
指向一个 SECURITY_ATTRIBUTES 的结构体,用它来标志新创建线程的安全性.如果为 NULL ,
那么新创建的线程就具有和主线程一样的安全性.
如果要在线程内结束线程,可以在线程内调用 AfxEndThread.
结束线程的两种方式
当你在后台用线程来打印一些图形时.有时在打印一部分后,你希望可以停下来,那么此如何让线程停止呢.下
面会详细的向你解释要结束线程的两种方式
1 : 这是最简单的方式,也就是让线程函数执行完成,此时线程正常结束.它会返回一个值,一般0是成功结束,
当然你可以定义自己的认为合适的值来代表线程成功执行.在线程内调用AfxEndThread将会直接结束线程,此时线
程的一切资源都会被回收.
2 : 如果你想让别一个线程B来结束线程A,那么,你就需要在这两个线程中传递信息.
不管是工作者线程还是界面线程,如果你想在线程结束后得到它的确结果,那么你可以调用:
::GetExitCodeThread函数
------------------------------------------------------------------------------------------------------------------------
SuspendThread 挂起（暂停）线程
函数原型：
DWORD SuspendThread(
HANDLE hThread //指定线程的句柄
);
这个函数的返回值：DWORD类型，如果这个函数成功,返回值是线程的前停止计数,否则,它(表示)- 1。
-------------------------------------------------------------------------------------------------------------------------------
ResumeThread 继续执行线程
函数原型：
DWORD ResumeThread(
HANDLE hThread //指定线程的句柄
);
这个函数的返回值：DWORD类型，如果这个函数成功,返回值是线程的前停止计数,否则,它(表示)- 1。
----------------------------------------------------------------------------------------------------------------------------------
WaitForSingleObject 终止线程
DWORD WaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
);
参数
hHandle
是一个事件的句柄
dwMilliseconds
在指定暂停区间,在毫秒。这个函数将返回如果区间流逝,即使该对象的状态是nonsignaled。如果dwMilliseconds是零,功能测试对象的状态和回报。如果dwMilliseconds是INFINITE的,这个函数的暂停区间从不流逝。
-run
