How to generate a sequential unique id in a thread-safe way

seems to work fine You can make it atomic by wrapping the increment in a lock. Since ++ requires three operations (fetch, add, store) I don't think it's atomic on its own on any platform.

Does that help In PHP, you can't access static class properties in object context. Instead of $this, you need to use self or static keyword, or the class name, coupled with :: operator instead of ->.
So, in your example, it's enough to change this line:

$this->empid = ++$this->counter;

$this->empid = ++self::$counter;
$this->empid = ++static::$counter;
$this->empid = ++Employee::$counter;

I think the issue was by ths following , If you're using active record then a unique sequential id (id) is already created by default and takes care of all concurrency issues for you. If you need to use it for queries then a separate column might be the way forward, but if you just need to display it in a certain format you could simply define a method on your model like:

class MyModel
  def my_unique_id
    "ABC%.5d" % id
  end
end

test = MyModel.create
test.id #=> 1
test.my_unique_id #=> "ABC00001"

test2 = MyModel.create
test2.id #=> 2
test2.my_unique_id #=> "ABC00002"

class Student
  acts_as_sequenced scope: :institute_id, column: :sequential_id
  #...
end

hope this fix your issue There is no way of enforcing a single-threaded use of your Consumer, at least not without an overhead in the same order of magnitude than just making the Consumer thread safe.
But it is not the responsibility of the Consumer to enforce a single-threaded usage. In Java, not being thread safe is the norm for mutable classes, say StringBuilder, ProcessBuilder, ArrayList, HashMap, any kind of iterator, DecimalFormat, to name some examples of widely used mutable classes which are not thread safe and not enforcing a single threaded use.

Does that help Interruption of tread can't happen at random point.
If someone call Thread.interrupt it doesn't stop thread immediately.