您还未登陆，请登录后操作！
股票名前加S是什么意思?
名前加S是什么意思?
10月9号开始对于尚未进行股权分置改革或者已进入改革程序但尚未实施股权分置改革方案的公司，在行情显示该股票简称前冠以“S”标记。
摘自官方通知
关于上市公司股权分置改革实施后有关交易事项的补充通知()
各上市公司、各会员单位：
目前上市公司股权分置改革已取得重大进展，绝大多数上市公司已完成股权分置改革。为更好地提示未股改公司风险，切实保护投资者权益，根据市场实际情况，本所决定调整有关公司股票简称前的标记。现就有关事项通知如下。
一、对于已完成股权分置改革、股票简称前冠以“G”的公司，其股票简称取消“G”标记，恢复冠以“G”标记以前的股票简称。
二、对于尚未进行股权分置改革或者已进入改革程序但尚未实施股权分置改革方案的公司，在行情显示该股票简称前冠以“S”标记。
三、简称被冠以“S”标记的股票，其交易制度目前暂不做调整。根据《关于上市公司股权分置改革的指导意见》（证监发[2005]80号）的精神，本所将按照上市公司股权分置改革整体安排，对该类股票的交易制度做出必要调整。
本通知自日起实施。
给以区别的表示。
您的举报已经提交成功，我们将尽快处理，谢谢！
大家还关注炒股大赛获奖公告：前10名选手将获500万操盘资金
　　和讯消息 北京时间2月6日，()第一期模拟赛结束争夺，选手“常州跨越巅峰”以25.80%收益勇夺冠军，“翼装飞行”和“趋势为尊”两位选手分列二三名。前10名选手将获得500万实盘资金进行实盘操作，500万实盘资金由33%的系统配资165万和67%的用户跟投资金335万组合进行分配，实盘操作资金使用时间为1个月。
　　请获奖者保持注册绑定手机畅通，如无法联系到获奖选手而导致不能发奖的，将由选手自己负责。获取更多大赛资讯，请关注和讯股票官方微信号istocknews
（责任编辑：HF054）
02/07 14:2402/07 11:3502/07 11:0302/06 19:4002/06 19:0802/06 18:2902/06 17:5102/06 17:28
每日要闻推荐
社区精华推荐
精彩专题图鉴
网上投洽会
　　【独家稿件声明】凡注明“和讯”来源之作品（文字、图片、图表），未经和讯网授权，任何媒体和个人不得全部或者部分转载。如需转载，请与010-联系；经许可后转载务必请注明出处，并添加源链接，违者本网将依法追究责任。炒股狂人从120万炒到10万 剽悍手法惊动券商_理解Python命名机制（单双上划线开头）_线程小结(sleep,join,yield,getPriority,setPriority,wait,notify,notifyAll)__脚本百事通
稍等，加载中……
^_^请注意，有可能下面的2篇文章才是您想要的内容：
炒股狂人从120万炒到10万 剽悍手法惊动券商
理解Python命名机制（单双上划线开头）
线程小结(sleep,join,yield,getPriority,setPriority,wait,notify,notifyAll)
炒股狂人从120万炒到10万 剽悍手法惊动券商
炒股狂人从120万炒到10万 强悍手法惊动券商炒股狂人从120万炒到10万 强悍手法惊动券商(被两大实力机构强力推荐的３只超牛)
[qq:] [代客理财赚钱三七分层] [今日推荐牛股(名单)QQ：] [跟着老股民做股票QQ：] 　　他，把自己的全部资产投入股市，不工作，全身心在家炒股。每天都在研究走势图，然而在相对集中的6个月，他亏损了百余万元。从他身上，你可能很难学到赚钱的技巧，但可以避免类似的亏损。　　日傍晚时分，北京的天空中忽然淅淅沥沥地下起了小雨，雨中夹着冷冷的风，带来了阵阵寒意，真是让人有了一场秋雨一场寒的感受。在西直门附近的一家火锅店，我和过去未曾谋面的老蒋在现实中碰面了。上身穿着一件黑外套的他留着寸头，一米八的大个子，略黑的眼圈让年近四十的他略微显得有些疲劳。　　我与老蒋是在一个炒股交流群认识的，经多次交流，我逐渐地被他的炒股经历所吸引。从2007年9月入市，到2009年10月份，他买过基金，炒过股票，玩过权证，期间有辉煌的战绩，而更多的是亏损。资金从120多万元缩水到10多万元，这对他生活影响很大，加上还得过一次心肌梗死，健康状况是很受到些影响了。但至今他对股市仍然充满兴趣，他表示，即使我的账户还有能够买一手股票的钱，我仍然要认真地选择股票进行操作，因为我不甘心。理由是不光为挽回投入的资金损失，而且股市是对人生最大的一种磨练，不甘心半途而废。　　正是他对股票的如此痴情，深深地触动了我，于是相约出来吃饭聊聊，想仔细听听他的投资故事和个中体会。　　入市前充分准备　　在进入资本市场前，老蒋是个做贸易的，做得还不错，当时他对股票一点都不懂。　　2007年，看着身边很多人从股市中赚钱，他的心也开始发痒。老蒋笑着说，这是他进入股市的主要原因。此外，当时他出售了手里的一套房子，让其有了进入股市的资金。同时，由于父亲身体不好，经常要去医院，家里需要有人照顾，所以他不愿意在外面跑着工作，就想找个在家也能赚钱的差事，于是他想到了股票。　　在开始操作股票前，他就听说股市中的风险非常大，所以他做了精心的准备。包括先以基金做试验，熟悉市场上的相关投资软件。　　2007年9月初，在决定进入股市前，他先尝试着买基金。买基金，他用了很多的方法和数据分析，得出的结论是：强者恒强。　　在回忆得出这个结论时，老蒋显得比较兴奋，他用手比划着说：“我把所有的基金做一个统计，随便拿一个时间，用基金的一个高点，去乘以一个倍数，就能算出它的能力。比如两个月或一个月之内，一个基金经理把他的业绩做得很好，就应该买他的，因为他对这段时间内经济情况、大势判断，以及他的操作思路，都是对的，这个时间内他就是一个强者。”　　沿着这样的投资思路，老蒋的收益很是不错，半个月的收益率就达到20%。　　此外，他还买了股票市场的几个主流操作软件。老蒋笑着说：“刚开始，我用生意人的思路来思考股票市场，对于目前股票市场上的主流交易软件，我要学习它、了解它。”于是，他就花了几千元买了几个交易软件。通过对软件的学习，他知道了什么是MA均线，什么是BBI多空指标，什么是EXPMA指数平均线。做了这么多的功课后，他认为自己对股票市场已经有所了解，便于9月底开始了其股海投资生涯。　　每天换股 全力以赴　　在谈及自己操作股票的风格时，老蒋说“每天换股”和“全力以赴”是我以前的投资特点。　　在刚开始投资股市时，老蒋作出投资决策的依据是每个交易日的分时走势图，用他的话说“我就是个纯粹的技术派，我相信“人定胜天”，从不相信什么价值投资，从分时走势图可以看出市场主力资金，如果分时走势图稳步上升，我就判断这种股票第二天不会跌，有可能当天就是涨停股；反之，就要出逃。”　　他9个月就达28页的交易记录，证明了自己是一个实实在在的技术投资者，而且是个超短线操作者。　　还记得第一次和他聊天时，他告诉我当天买的华芳纺织(600273)，当天该股微跌收盘。第二天，华芳纺织涨势不错，于是发信息过去恭喜他，而他则表示，看早上的分时走势不好，就在低点时已经卖了，并已经买了风神股份(600469)、罗顿发展(600209)。又过一天，他买的股票又换了，以至于后来我只问他的收益怎么样，而不问他买了什么股票，因为他换的太快了。　　“以前，我只要有资金在股票账户里，每天开盘的时间我都很忙，精神高度紧张，不停地研究个股的每日走势，以便能找到我认为比较理想的股票。我换股很频繁，基本上每天都换，即使是同一只股票，我也要每天进出一次，而做权证的时候，我每天能进出几十次。”谈及换股的频率时，老蒋笑呵呵地如是说。　　从最初入市到现在，总共操作了多少只股票，老蒋早已不记得了，因为太多。而令普通投资者难忘的第一只股票和基金，他也是不好意思的笑着说“不记得了”。　　让他用这种超短线手法操作股票的主要因素，是他之前一直信奉的“人定胜天”的理论。在他看来，股票市场中很多股票的价格与其实际价值并不相符，而决定股价的主要因素是市场对该股价的认同度，也就是人与人之间的博弈，而这种博弈的主力就是市场的主力资金。所以他坚持“强上弱买，弱下强卖”的方针，而他的投资依据则是股票的每天分时走势图，据此来判断主力资金的动向，进而决定是买还是卖。　　与一般投资者把部分资金投入股市所不同的是，老蒋是把自己的所有资金都打入了股票账户中。2007年，他出售一套房子获得了175万元，除去给老爸看病花了30万元，以及在奥运村买了一套房子花了50多万，账户中还剩80多万元，这些资金全部投入到股市中。　　我说他的这种心态是“破釜沉舟”，他却说是“全力以赴”。他表示：这是他的做事风格，每当做一件事，都是全身心的投入。　　他的这种“全力以赴”的理念，还体现在他的选股思路上。一般投资者往往会把账户中的资金分别买入几只股票，分散风险，用经济学上的一句名言叫“不要把鸡蛋放在一个篮子里”。　　而老蒋则不这么认为，他偏偏把鸡蛋都放在一个篮子里，当认定了一只股票时，他会把所有的资金都买入这只股票，无论他的判断是对还是错，即使错了，他也不后悔。　　吃得有点热的老蒋，一边吸着烟，一边笑着对我说：“从一开始买股票，到现在，我基本上都是满仓一只股，很少会同时买两只股票，98%的时间里，我都是这样操作的。”　　超短线的手法和“全力以赴”，让他曾经很辉煌，但收获更多的则是亏损。　　强悍手法惊动证券公司　　频繁的进出，让老蒋每天进入股市资金流量都比较大，特别是权证，当时他大胆的操作引起了证券公司的关注。2008年6月初，停牌达半年之久的荣华实业(600311)复牌，被套已久的老蒋在复牌后赶紧撤离了荣华实业，转头开玩权证。　　当时，正赶上南航权证的末日疯狂。老蒋觉得权证很刺激，一天能进出好多来回，加之杠杆效应，让他迷上了权证。而权证的T+0交易制度，更是让老蒋玩得不亦乐乎。　　刚开始做权证，他比较小心。第一天做权证，开始赚了几个点的，由于判断不准，随后就出来了；然后看着涨了，又进去。就这样不断地反复，第一天他赚了5多万元，这让他欣喜不已。　　他把这个消息告诉了当初给他开户的邻居。这位邻居是某证券公司的部门主管，听说他这么玩权证，就劝他不要玩，因为太危险，很多证券公司的人都不敢做。不过，他并没有听从邻居的劝告。　　“那之后的三四天，我一直频繁地进出南航权证，有时一天能进出20多次。由于涨势比较好，我从中挣了近20万元，每天带动的资金量达上千万元。这种操作南航权证的手法，让我邻居所在的证券公司炸开了锅，他和他的同事那几天都在讨论我炒作南航权证的事，连他的经理都想跟我比比操作权证的技术。”在谈及曾经的辉煌，老蒋眉飞色舞。　　不过，这样幸福的日子并没有几天。由于对权证不够了解，老蒋没想到权证有时会一文不值。当南航权证从高点跌幅达70%的时候，他认为投资的机会来了，就全部进入，结果南航一路下滑，把前几天赚的20多万又都赔了进去。“现在，我手上还有100手南航权证呢。”老蒋无奈地笑着说。　　六个月亏损百余万　　在2008年单边下跌的行情中，很多人割肉离场，但老蒋没有。由于2008年上半年他的资金被关在荣华实业里面，他“被迫”躲过了上半年熊市的摧残，这让他在大盘暴跌的行情下，并没有亏损多少。也许正是这样的“无意保护”，让他没有感觉到熊市的真正可怕之处。　　经历了南航权证的起伏，老蒋依然在开盘的时间很忙碌、很紧张，忙着看大盘，忙着看个股的每日走势图，忙着每天换股票。然而，“大熊”已经悄悄地向这位新股民伸出了魔掌。　　在熊市的下半年，大部分股票仍都处于下跌中，所以老蒋每换一只股票，基本上都亏钱，每只股票亏了一两万元。　　“当时，这么小的亏损额，我并不在意。我依然每天在换股票，就这么每天亏，每天换，后来也麻木了。到9月中旬的时候，我的股票账户从80多万元只剩下几千元，我都不知道当时是怎么亏的。现在回想起来，都觉得好像中邪了。”回忆当时的情景，老蒋脸上依然挂着笑容，但笑容中带着几分苦涩。　　加上家里的一些原因，以及长期看盘的高度紧张，让老蒋在2008年9月中旬得了心肌梗死，不得不入院治疗。之后在家休养，一直到2009年的7月底。　　身体休养差不多的老蒋，将此前在奥运村买的一套房子卖了近40多万元，随后又开始投入股市。　　重回股市的老蒋，依然沿着此前的方式继续进行股票操作。在大盘上升的7月份，战绩尚可，但接下来的8、9、10月份，让他很是郁闷，他再次亏得一塌糊涂，股票账户中的金额从40多万元慢慢的就变成了10万元。“我都不知道为什么会亏损这么多，今年这几个月的经历和去年的7、8、9月份特别相似，我觉得很邪乎。”谈及自己今年亏损的原因，他有点百思不得其解。　　改变思路 依然坚持　　从120多万元的本金，到只剩下10万元，这样的巨额亏损给老蒋的生活带来了很大的影响。以前经常开车出去的他，现在车也卖了，同时，他也认真反思自己的投资理念和操作手法。“我要改变我的炒股思路，我不能再赔了，不然我连养老的钱都没有了。”　　他表示：我现在已经不再奉行“人定胜天”的理念，而开始相信“天人合一”，即结合大盘选择个股。2008年的时候，在大盘暴跌的情况下，我依然相信自己能赚钱，可结果证明我错了，也许这就是覆倾巢之下无完卵的道理。所以我还是要顺势而为，同时要改变自己的每天换股的思路，看好了一只股票尽量多拿几天，这样自己每天不会那么紧张，那么疲惫。　　除了炒股风格的改变，老蒋也决定在生活上有所改变，他喝着菊花茶说：“以后不会再全职炒股，希望找一个工作或者做个什么生意，以转移自己的注意力。因为物质的压力越来越重，毕竟生活还是要继续下去。”　　“即便这样，我也永远不会离开股市，仍然不会放弃。即使我的账户还有能够买一手股票的钱，我仍然要认真地选择股票进行操作，因为我不甘心。不光是为挽回投入的资金损失，还因为我喜欢股市，它是人生最大的一个磨练场，而我不甘心半途而废。”在晚餐即将结束的时候，老蒋平静地对我说。他眼中透露出来的坚定，让我觉得他是个永不放弃的人。　　→专家支招　　以蒋先生的投资经历来看，记者采访了几位券商分析师，他们指出了其中的症结，并给出一些建议。　　【症结】　　A：单纯依靠每日分时走势图做出投资决策，太过单一。　　B：每天都换股，撇开盈亏不说，单是这么久以来的手续费就不少。　　C：每天开盘时神经紧绷，心态不好。　　D：把全部资产都投入到股市中，这种做法不可取，有种放手一搏的感觉。　　【建议】　　A：把研究的范围放大，包括宏观经济、行业经济、大盘走势、多日K线图。　　B：把重点放在自己感兴趣的一个或几个行业上，从中选择几个自己比较看好的公司，长期研究，反复操作。　　C：设立盈亏目标，当到达自己的盈亏点时应坚决出货，以此来替代每天都换股的操作手法，以放松身心。　　D：分散风险，改变满仓一只股的做法，多买几只自己看中的股票，不至于一次亏损过大。　　E：寻找一份工作或做点其他事情，增加经济来源。股市是赚钱的途径之一，不是唯一能赚钱的工具。通常情况下，投资股票的资金应是自己全部财产的20%，而不是全部。
理解Python命名机制（单双上划线开头）
理解Python命名机制（单双下划线开头）本文最初发表于恋花蝶的博客（http://blog.csdn.net/lanphaday），欢迎转载，但必须保留此声明且不得用于商业目的。谢谢。
我热情地邀请大家猜测下面这段程序的输出：
class A(object):
def __init__(self):
self.__private()
self.public()
def __private(self):
print 'A.__private()'
def public(self):
print 'A.public()'
class B(A):
def __private(self):
print 'B.__private()'
def public(self):
print 'B.public()'
正确的答案是：
A.__private()
B.public()
如果您已经猜对了，那么可以不看我这篇博文了。如果你没有猜对或者心里有所疑问，那我的这篇博文正是为您所准备的。
一切由为什么会输出“A.__private()”开始。但要讲清楚为什么，我们就有必要了解一下Python的命名机制。
manual，变量名（标识符）是Python的一种原子元素。当变量名被绑定到一个对象的时候，变量名就指代这个对象，就像人类社会一样，不是吗？当变
量名出现在代码块中，那它就是本地变量；当变量名出现在模块中，它就是全局变量。模块相信大家都有很好的理解，但代码块可能让人费解些。在这里解释一下：
代码块就是可作为可执行单元的一段Python程序文本；模块、函数体和类定义都是代码块。不仅如此，每一个交互脚本命令也是一个代码块；一个脚本文件也是一个代码块；一个命令行脚本也是一个代码块。
接下来谈谈变量的可见性，我们引入一个范围的概念。范围就是变量名在代码块的可见性。
如果一个代码块里定义本地变量，那范围就包括这个代码块。如果变量定义在一个功能代码块里，那范围就扩展到这个功能块里的任一代码块，除非其中定义了同名
的另一变量。但定义在类中的变量的范围被限定在类代码块，而不会扩展到方法代码块中。
据上节的理论，我们可以把代码分为三个代码块：类A的定义、类B的定义和变量b的定义。根据类定义，我们知道代码给类A定义了三个成员变量（Python的函数也是对象，所以成员方法称为成员变量也行得通。）；类B定义了两个成员变量。这可以通过以下代码验证：
&&& print '\n'.join(dir(A))
_A__private
&&& print '\n'.join(dir(B))
_A__private
_B__private
咦，为什么类A有个名为_A__private的 Attribute 呢？而且__private消失了！这就要谈谈Python的私有变量轧压了。
懂Python的朋友都知道Python把以两个或以上下划线字符开头且没有以两个或以上下划线结尾的变量当作私有变量。私有变量会在代码生成之前被转换为长格式（变为公有）。转换机制是这样的：在变量前端插入类名，再在前端加入一个下划线字符。这就是所谓的私有变量轧压（Private name mangling）。如类
A里的__private标识符将被转换为_A__private，这就是上一节出现_A__private和__private消失的原因了。
再讲两点题外话：
一是因为轧压会使标识符变长，当超过255的时候，Python会切断，要注意因此引起的命名冲突。
二是当类名全部以下划线命名的时候，Python就不再执行轧压。如：
&&& class ____(object):
def __init__(self):
self.__method()
def __method(self):
print '____.__method()'
&&& print '\n'.join(dir(____))
__delattr__
__getattribute__
__module__
__reduce__
__reduce_ex__
__setattr__
__weakref__
&&& obj = ____()
____.__method()
&&& obj.__method()
可以外部调用
____.__method()
现在我们回过头来看看为什么会输出“A.__private()”吧！
相信现在聪明的读者已经猜到答案了吧？如果你还没有想到，我给你个提示：真相跟C语言里的宏预处理差不多。
因为类A定义了一个私有成员函数（变量），所以在代码生成之前先执行私有变量轧压（注意到上一节标红的那行字没有？）。轧压之后，类A的代码就变成这样了：
class A(object):
def __init__(self):
self._A__private()
self.public()
def _A__private(self):
这行也变了
print 'A.__private()'
def public(self):
print 'A.public()'
是不是有点像C语言里的宏展开啊？
因为在类B定义的时候没有覆盖__init__方法，所以调用的仍然是A.__init__，即执行了self._A__private()，自然输出“A.__private()”了。
下面的两段代码可以增加说服力，增进理解：
&&& class C(A):
def __init__(self):
，不再调用
self._A__private
self.__private()
这里绑定的是
_C_private
self.public()
def __private(self):
print 'C.__private()'
def public(self):
print 'C.public()'
&&& c = C()
C.__private()
C.public()
############################
&&& class A(object):
def __init__(self):
self._A__private()
调用一个没有定义的函数，
会把它给我的
self.public()
def __private(self):
print 'A.__private()'
def public(self):
print 'A.public()'
&&&a = A()
A.__private()
A.public()
线程小结(sleep,join,yield,getPriority,setPriority,wait,notify,notifyAll)
线程总结(sleep,join,yield,getPriority,setPriority,wait,notify,notifyAll)1.sleep
是Thread的静态方法，public static void sleep(long mililis) throws InterruptedException 使得当前线程处于休眠状态。Tread.sleep();
sleep() 允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间片，指定的时间一过，线程重新进入可执行状态。说白了 ，也就是把机会给其他线程，但是监控状态依然保持。重要的一点就是 当调用sleep（）方法是 不会 释放对象锁的。
public class SleepTest implements Runnable {
static int b = 100;
public void run() {
System.out.println("m1");
Thread.sleep(5000);
System.out.println("m1" + "Thread=" + Thread.currentThread().getName()
+ " " + this + " " + "b=:" + b);
} catch (Exception e) {
e.printStackTrace();
public static void main(String args[]) throws Exception {
SleepTest ss = new SleepTest();
Thread tt = new Thread(ss);
Thread tt1 = new Thread(ss);
tt.start();
tt1.start();
运行结果：
m1Thread=Thread-0 CopyOfsynchro@f62373 b=:98
m1Thread=Thread-1 CopyOfsynchro@f62373 b=:98
2.wait,notify,notifyall
是Object 类的方法。所有对象都拥有这一对方法。这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。
notify（）是释放对象的wait（）方法而阻塞线程（但是也要当得到锁后才可以运行）但是这个释放是随机的，也就是不一定要释放那个线程。（因为调用同一资源的可能不是一个线程或者说是有多个阻塞的线程在等待，但是如果加了synchronized也只有一个线程，也有其他的线程在等待中，也就是阻塞）我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。 除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。 　　同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现 IllegalMonitorStateException 异常。
举例：生产者与消费者
public class ProducerConsumer {
public static void main(String args[]){
SyncStack ss = new SyncStack();
Producer p = new Producer(ss);
Consumer c = new Consumer(ss);
new Thread(p).start();
new Thread(c).start();
class WoTou{
public WoTou(int id){
public String toString(){
return "WoTou:"+
class SyncStack{
int index = 0;
WoTou[] awtWT = new WoTou[6];
public synchronized void push(WoTou wt){
while(index == awtWT.length){
this.wait();//当前的正在访问对象的线程wait
} catch (InterruptedException e) {
e.printStackTrace();
this.notify();
awtWT[index] =
public synchronized WoTou pop(){
while(index == 0){//if-&while：如果catch住异常后，假如是if并且index=0，index == 0 不再判断，index--会执行， 程序错误。所以改为while,可以避免发生如此错误。
this.wait();//当前的正在访问对象的线程阻塞（wait）,wait后对象的锁不归线程所有，直到"醒了"（notify,notifyALL），再重新找回锁。
} catch (InterruptedException e) {
e.printStackTrace();
this.notify();//叫醒一个正在当前对象上wait的线程。
return awtWT[index];
class Producer implements Runnable{
SyncStack ss =
Producer(SyncStack ss){
public void run() {
for(int i=0;i&20;i++){
WoTou wt = new WoTou(i);
ss.push(wt);
System.out.println("Producer："+wt);
Thread.sleep((int)(Math.random()*100));
} catch (InterruptedException e) {
e.printStackTrace();
class Consumer implements Runnable{
SyncStack ss =
Consumer(SyncStack ss){
public void run() {
for(int i=0;i&20;i++){
WoTou wt = ss.pop();
System.out.println("Consumer："+wt);
Thread.sleep((int)(Math.random()*1000));//目的是让其他线程有执行的机会。
} catch (InterruptedException e) {
e.printStackTrace();
执行结果：
Producer：WoTou:0Consumer：WoTou:0Producer：WoTou:1Producer：WoTou:2Producer：WoTou:3Producer：WoTou:4Producer：WoTou:5Producer：WoTou:6Consumer：WoTou:6Producer：WoTou:7Producer：WoTou:8Consumer：WoTou:7Producer：WoTou:9Consumer：WoTou:8Consumer：WoTou:9Producer：WoTou:10Consumer：WoTou:10Producer：WoTou:11Consumer：WoTou:11Producer：WoTou:12Consumer：WoTou:12Producer：WoTou:13Consumer：WoTou:13Producer：WoTou:14Consumer：WoTou:14Producer：WoTou:15Consumer：WoTou:15Producer：WoTou:16Consumer：WoTou:16Producer：WoTou:17Consumer：WoTou:17Producer：WoTou:18Consumer：WoTou:18Producer：WoTou:19Consumer：WoTou:19Consumer：WoTou:5Consumer：WoTou:4Consumer：WoTou:3Consumer：WoTou:2Consumer：WoTou:1
合并某个线程。（相当方法调用）
public class TestJoin implements Runnable {
static int b = 100;
public void run() {
System.out.println("m1");
System.out.println("m1" + "Thread=" + Thread.currentThread().getName()
+ " " + this + " " + "b=:" + b);
} catch (Exception e) {
e.printStackTrace();
public static void main(String args[]) throws Exception {
TestJoin ss = new TestJoin();
Thread tt = new Thread(ss);
Thread tt1 = new Thread(ss);
tt.start();
tt.join(); //合并线程
tt1.start();
运行结果：
m1Thread=Thread-0 TestJoin@12b6651 b=:99
m1Thread=Thread-1 TestJoin@12b6651 b=:98
让出ＣＰＵ给其他线程执行的机会。
public class TestYield extends Thread {
public void run() {
for (int i = 0; i & 100; i++) {
System.out.println(Thread.currentThread().getName() +"i=:" + i);
if(i%10==0){
yield(); //让出线程执行
} catch (Exception e) {
e.printStackTrace();
public static void main(String args[]) throws Exception {
Thread tt = new TestYield();
Thread tt1 = new TestYield();
tt.start();
tt1.start();
5.getPriority,setPriority
Java 提供一个线程调度器来监控程序中启动后就进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪个线程来执行。
线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级是5。
Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY=10
Thread.NORM_PRIORITY = 5
使用下述方法获得或设置线程对象的优先级。
int getPriority();
void setPriority(int nexPriority);
public class TestPriority extends Thread{
public void run() {
for(int i=0;i&10;i++){
System.out.println("m1" + "Thread="
+ Thread.currentThread().getName() + " " + this + " "
+ "i=:" + i);
} catch (Exception e) {
e.printStackTrace();
public static void main(String args[]) throws Exception {
Thread ss = new TestPriority();
Thread tt = new TestPriority();
ss.start();
tt.start();
tt.setPriority(Thread.NORM_PRIORITY + 4);
一种运行结果：
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:0m1Thread=Thread-1 Thread[Thread-1,9,main] i=:0m1Thread=Thread-1 Thread[Thread-1,9,main] i=:1m1Thread=Thread-1 Thread[Thread-1,9,main] i=:2m1Thread=Thread-1 Thread[Thread-1,9,main] i=:3m1Thread=Thread-1 Thread[Thread-1,9,main] i=:4m1Thread=Thread-1 Thread[Thread-1,9,main] i=:5m1Thread=Thread-1 Thread[Thread-1,9,main] i=:6m1Thread=Thread-1 Thread[Thread-1,9,main] i=:7m1Thread=Thread-1 Thread[Thread-1,9,main] i=:8m1Thread=Thread-1 Thread[Thread-1,9,main] i=:9m1Thread=Thread-0 Thread[Thread-0,5,main] i=:1m1Thread=Thread-0 Thread[Thread-0,5,main] i=:2m1Thread=Thread-0 Thread[Thread-0,5,main] i=:3m1Thread=Thread-0 Thread[Thread-0,5,main] i=:4m1Thread=Thread-0 Thread[Thread-0,5,main] i=:5m1Thread=Thread-0 Thread[Thread-0,5,main] i=:6m1Thread=Thread-0 Thread[Thread-0,5,main] i=:7m1Thread=Thread-0 Thread[Thread-0,5,main] i=:8m1Thread=Thread-0 Thread[Thread-0,5,main] i=:9
优先级高的运行时间长。
如果您想提高自己的技术水平，欢迎加入本站官方1号QQ群：&&，&&2号QQ群：，在群里结识技术精英和交流技术^_^
本站联系邮箱：