国内招聘的好多职位，好多要求35岁以下。现实好残酷。

你说的是技术岗吧，管理岗肯定不是这样的。30-40岁不到这个岁数你想跳cto岗还不容易呢。

没事看看大马的一把手93了

我见过要求30岁以下的并不是admin一类的基础职位，是分公司的财务经理....

现实是35岁以上找工作还需要盲投简历的话，人生就太失败了。35岁以上，找工作要靠人脉，要么自己是老板。

问题是有的人不愿意做管理岗啊只喜欢做技术。做管理的又不一定比做技术的挣得多，两条track而已。

另外管理岗的人普遍技术一般般，没有什么过硬的吃饭本领，这种人失业了往往更难找工作。

cto，technical director 也算是管理岗啊，也可以一样做技术啊。。只是单纯的别人指导你，而你只是做最基础的工作（例如程序员函数别人都设计好了，你来写这种的），年纪越大是越难混了。哪个国家都一样，不单单是中国。

你应该不是搞技术的你说的那些cto director之类的职位明显是管理岗，而不是技术岗了。

我说的在technical track一路走下去的，并不是要管人，而是在某一个领域成为技术专家。比如java之父james gosling这种级别的大牛，都62岁了，到现在为止也就是亚马逊的一个distinguished engineer，并不需要去管人，但他在一个特定的技术领域是公司里广受尊敬的sme（subject matter expert），工资也并不比公司内部同级别的management track低，这就是在技术岗一路走下去的典型例子。

当然像你说得那种年纪很大，但技术能力一点儿都没长进，仍然只能在technical track上做一些初级工作的人，的确是在哪里都不太好找工作了。

那种高级技术专家，在国内会因为年龄找不到工作？那种只要35的，是因为他只想招你过去当低级码农而已。。

我还真是搞技术的，今年37了。我写的代码，我相信本论坛能看懂的人都不多。例如，上周五刚写的。。

只是一个大的分布式存储数据结构中的mutex 。。基本没有版权问题，因为你拿来也没法用，是专门为特殊的结构写的。。

class shared_mutex {
struct lock {
// The top-most bit (exclusive) is an exclusive lock and only one thread
// is able to acquire the exclusive successfully. This bit indicates whether
// a thread successfully acquires the lock.
//
// Note that, once an exclusive lock is locked, it will never be unlocked unless
// the node is not modified due to some other errors.
//
// This is because it is non-sense to lock the same node to write twice: once
// a node is written to another copy, the old one will be put on readonly_list
// and will never be written again.
uint64_t exclusive : 1;
// Indciates the unique ID of this thread.
uint64_t id : 48;
// Number of threads that are going to write on the nodes beneath the current node.
uint64_t shared_count : 15;
};
std::atomic<lock> lock_ { {0, 0, 0} };

public:

// Try to acquire a shared lock (increase shared count by 1).
// The try lock shared can also be temporally blocked for a small time if
// someone else is also modifying the shared_count (either add or subtract)
// concurrently.
//
// It will only fail when someone else got the exclusive lock (i.e., will
// modify the current node).
//
// We do not provide block version of lock_shared because it's non-sense
// to wait for a writing thread (which may change current node as well as
// the parent nodes). We have to return false and release all the shared lock
// of parents path to allow the current writing thread to possibly proceed
// (to avoid dead lock).
bool try_lock_shared() noexcept {
// When there is already a write lock (meaning someone is waiting for
// write permission on the current node), return false (we don't allow
// any new thread to change on any node beneath the current node).
// They must wait for the current node to realese exlcusive_lock before
// continuing.
lock currentlock = lock_.load();
if (currentlock.exclusive == 1) {
return false;
}

// If failed, meaning that someone else modified the current lock.
// If someone else obtains exclusive lock, we just simply return fail.
// If someone else just changed shared count (add or subtract), we try agian.
// We assume that such shared count change can't be blocked forever.
lock newlock;
do {
newlock = currentlock;
newlock.shared_count++;
}
while(!lock_.compare_exchange_weak(currentlock, newlock) && currentlock.exclusive == 0);

// If return true, we can be sure that no one else got exclusive lock for writing yet.
return currentlock.exclusive == 0;
}


// Unlock a shared lock (decrease the count by 1).
// Will always return true. May be blocked for a small time.
void unlock_shared() noexcept {
lock currentlock = lock_.load();

lock newlock;
do {
newlock = currentlock;
newlock.shared_count--;
}
while(!lock_.compare_exchange_weak(currentlock, newlock));
}


// Check whether shared lock is 0
bool check_all_shared_unlocked() noexcept {
lock currentlock = lock_.load();
// The thread who calls this, must be the thread that
// obtains the exlcusive lock.
assert(currentlock.id == utils::get_thread_id());
return currentlock.shared_count == 0;
}

// Wait for shared lock to be 0 for a specified duration.
bool wait_all_shared_unlocked_for(const std::chrono::nanoseconds &duration) noexcept {
return wait_all_shared_unlocked_until(std::chrono::high_resolution_clock::now() + duration);
}

// Wait for shared lock to be 0 until the given time.
bool wait_all_shared_unlocked_until(const std::chrono::high_resolution_clock::time_point &expire) noexcept {
bool result = false;
while( std::chrono::high_resolution_clock::now() < expire && !(result = check_all_shared_unlocked()) ) {
std::this_thread::yield();
}
return result;
}

// Wait for shared lock to be 0.
void wait_all_shared_unlocked() noexcept {
while (!check_all_shared_unlocked() ) {
std::this_thread::yield();
}
}

// Try to acquire an exclusive lock. It will set exlusive to be 1, and id to be the
// unique thread id.
//
// Will only fail if exclusive lock is obtained by some other thread.
//
// No blocking version is provided because it is non-sense to wait for another
// thread who has already writing permission (although the write may not be finalized,
// but we have to return fail and release all current shared lock to avoid dead lock).
bool try_lock() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
if (currentlock.exclusive == 1) {
// If the same thread called try_lock on already locked mutex,
// it means we have some logic error somewhere.
assert(currentlock.id != id);

return false;
}

bool result = false;
lock newlock { 1, id, 0 };
do {
newlock.shared_count = currentlock.shared_count;
}
while(!(result = lock_.compare_exchange_weak(currentlock, newlock)) && currentlock.exclusive == 0);

return result;
}


// Unlock the exlusive lock. Shall only be called if no writing is done
// on the node (e.g., due to recursive exclusive call failed for parents node.)
void unlock() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
assert(currentlock.exclusive == 1 && currentlock.id == id);

lock newlock { 0, 0, 0 };
do {
newlock.shared_count = currentlock.shared_count;
}
while (lock_.compare_exchange_weak(currentlock, newlock));
}

// Try to convert a shared lock to an exclusive lock.
// If successful, shared lock will be unlocked.
// If failed, nothing will be changed.
bool try_shared_to_exclusive() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
if (currentlock.exclusive == 1) {
assert(currentlock.id != id);
return false;
}

bool result = false;
lock newlock { 1, id, 0 };
do {
assert(currentlock.shared_count > 0);
newlock.shared_count = currentlock.shared_count - 1;
}
while(!(result = lock_.compare_exchange_weak(currentlock, newlock)) && currentlock.exclusive == 0);

return result;
}

// Try to convert an exclusive lock to a shared lock.
// If successful, exclusive lock will be released.
// This function will not fail.
void exclusive_to_shared() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
assert(currentlock.exclusive == 1 && currentlock.id == id);

lock newlock { 0, 0, 0 };
do {
newlock.shared_count = currentlock.shared_count + 1;
}
while (lock_.compare_exchange_weak(currentlock, newlock));
}
};

什么公司需要写分布式底层多线程代码？

就是普通的C++代码，看得懂的应该不少。用在数据库这段代码还可以优化一下atomic可以考虑优化memory order，比如memory_order_relaxed/memory_order_consume。
uint64_t, atomic变量分开在不同的CPU cache line并对齐多线程性能会更好

So?0514
What is the point?

你这段代码的质量我就不评价了我只是想问就这种水平的程序员，国内能开到多少工资？

你不如评价评价质量让我学习一下？我是做外包的，客户有需求就做。核心代码都是我自己亲自动手的。

我工资自己定的，所以问我的工资无统计意义。

认识的朋友在联通/平安之类的，带领一个小百人团队的大数据研发部门，大概50-100之间。

x64 优化意义不是很大。并且还没到优化阶段。公司核心资源有限。

我只是说明我在做技术。翻了翻最近写得，只能拿出这么一小段和其他关联几乎没有的。其他拿出来就没法贴了，。

有人直接说我不是搞技术的，只是证明一下我在搞技术。

并且我看你的评论在关注代码本身。这段代码本身没什么我公司里告诉他设计接口，要求，注意事项，能放心让他去写，差不多达到这个质量的就好几个（我真的是小公司）。只不过花的时间有多有少罢了。如果没有好几个质量靠谱的人，我也不可能采用激进的c++17来做这个项目，直接拿个开源的来抄抄也够了。我心里是想在这部分有技术积累（我们以前没做过数据库相关项目）。

关键是，整套系统的设计。就比如这个类，我为何要提供这几个api，有哪几个其他选择，优缺点各是什么，api接口怎样设计，怎样用这几个api。这才是关键。我指的能看懂的人不多，主要是指这些方面。。当然我是说大眼一看上去就了解（即自己也有比较高的水平或相关经验的人），再复杂的系统，只要花时间，能看懂的人当然很多很多。。

最近几年的项目一半以上都是多线程的。。大数据相关项目还没有不是分布式的。

你如果能在某个领域能达到我说的水平，就比如说分布式数据库能达到这个水平去bat做核心人员应该没问题。工资水平我不了解了。

我个人其实达不到，因为这段代码虽然写起来很快，但设计的时候我还是花了很多时间去思考学习其他开源代码的。

所以我说这论坛大部分看不懂我写的代码，主要是指没几个人能短时间内了解到我背后的设计和思考的过程，以及没下过我学习阅读的n多其他开源代码的功夫。也许口气有些狂了大家都不开心？

我们平时业务也不在这一块，最近几年刻意去接触大数据/大型抓取/人工智能的项目，第一是因为这部分项目钱多，第二也是为自己公司做技术积累。

牛人你好不错啊

你做哪方面的？金融？

不明觉厉厉害

是不是可以接私活？ 据说自己私下接货可以赚很多

求解惑1。C++调用被C compiler编译后的函数，为啥加extern “C”
2。＃include<huaxin.h> 跟＃include "huaxin.h"有啥不同
3。既然有了malloc/free，为啥还需要new/delete
4。main run之前会执行什么？run之后能执行代码吗？

层主认真的么第一个stackoverflow上一堆答案，3，4都是csapp上的核心知识点，第二个不知道问的啥，我猜是<> “”的区别？

有着精力不如炒房地产国内大把的大爷大妈还在琢磨为什么不叫A语言？早就实现n套房产，财富自由，财产滚雪球滚大了。。。

玩技术，给人打工，和工地民工有啥区别？醒醒吧，随便找个大学生钻研一个月就做到了，也就1／5的钱，过两年估计机器人自动编程。打工就这命，50笑51

技术做得好，真不需要投简历。圈子都不大，你行别人会知道。
我哥一农民，出去打工，因人老实可靠能干，40多失业（所在公司破产），一样有N个老板递来橄榄枝。他还是非技术人员，做采购。

因为他的工作替代成本更高，销售员靠业绩不适资历混得。有的工作反过来德，。。。

好码农还是很厉害的别个组有个美国小伙子很能干，别人写一天他一个小时就码完了，看着他从三十多岁码到四十多岁，职位涨了好几次了还在继续码。和年轻与否没关系，码的好多大都能码。

美国可以，小坡depends, 中国不可能最简单看，美国找工作问年龄是违法的， 小坡像样的公司也不问，找人的时候 HR向我强调不可以问这，但可以猜
中国找工前三个问题就有一个是年龄，什么级别都是， 人家把这个当成你价值一部分拉。你技术高，找几个跟你学，学完你就可以离开了， 这个话不是我说的

层主你又来骗我们去美国么？简历里面不是有年龄么？如果简历里面没有年龄，HR又shortlist了这份简历，HR吃什么干的？

在美国照样的，简历里面也要写年龄，不写，HR会shortlist你？

新加坡除了宗教相关的，其余的什么年龄，随便问，不会有任何问题的啊。

你简历里放年龄不等于别人放阿国内的习惯是防年龄。
我有一次犯傻问了人家，人家直接告诉我不方便说可以么。。

不过如果通过劳务中介找人的确他们都放如果你直接申请，很多公司貌似没有这个年龄选项的。
一般专业猎头（中国除外）都不会问

美国的问题不是年龄是吸毒和犯罪，你敢和毒贩子，变性人，杀人犯一起共事么。　

高级职位公开招聘很少一般都是熟人介绍，或者是猎头去挖的。高级职位的入职成本很高，如果找的不合适，公司损失很大。所以一般都是熟人或者同行业里面挖角。

坡上都要ic呀ic号码直接就能看出年纪呀
面试可以不说年纪和家庭情况吗
每次一说到娃就各种问题呀

你放心大家没空看这个的。。公司也不会有这个规定　你自己写出来，就会注意了。

re招人就是根据毕业时间和工作年限大概算一个年龄就好了，比如都假设男的25毕业，工作10年就是35了，然后就按这个range的要求就好了，又不用知道特别详细的年龄

不过话说回来，前面也有人提到了，越senior的位置，招人的成本越高，match度也会要求比较高，所以一般还是比较喜欢通过猎头或者熟人来招。所以市场上公开的senior position就会相对比较有限，这样大约会造成senior不好找工作的现象，这都是很正常的。

至于年龄歧视，很多时候其实并不是这么回事，有时候我明明想招个junior position，来个senior我自己也很难办啊，毕竟budget有限，也比较难justify

年轻人的优势在于学习本领要说技术高，码这个东西过几年更新换代一次，就是要快。
学的快的话年龄才不是屏障，高龄低龄都可以，小学生都能做出东西来，同理，80岁老婆婆也可以。
35岁以上的程序员没有价值，那大概是思维僵化的管理层的误区。

There are always some people whom cannot be defined or measured by money0515

【吐槽八卦】国内招聘的好多职位，好多要求35岁以下。现实好残酷。
该帖荣获当日十大第6，奖励楼主8分以及12狮城帮币，时间：2018-05-14 22:00:04。该帖荣获当日十大第3，奖励楼主15分以及22狮城帮币，时间：2018-05-15 22:00:01。