Method and system for parallel mark processing

1. A method, comprising:

traversing first objects in a virtual machine heap based on correspondences between memory blocks in the virtual machine heap and N marking threads, wherein N is an integer greater than 1, wherein memory capacity occupied by the N marking threads is preset, wherein each marking thread includes a corresponding private stack, and wherein the memory capacity includes a thread memory capacity of N private stacks;

pushing a first pointer of a first object of the first objects into a private stack of a marking thread corresponding to a memory block, the first object being located in the memory block, comprising:

determining whether the private stack of the marking thread is full;

in response to a determination that the private stack of the marking thread is full:

marking the private stack as overflowing; and

marking the first object as having an overflowed status for a push-in condition; and

performing one or more of the following:

recording, in a list form, the push-in condition of the first object corresponding to the private stack of the marking thread; and/or

marking a status corresponding to the first object in a bitmap of the memory block where a current first object is located;

performing first mark processing of the first object based on the push-in condition of the first pointer, comprising:

determining whether the private stack is overflowing; and

in response to a determination that the private stack is overflowing, omitting to perform the first mark processing of the first object until the private stack has new processing space;

after traversal of the first objects has been completed, launching the N marking threads to cause the N marking threads to synchronously perform mark processing used in garbage collection based on push-in conditions of first pointers in respective private stacks of the first pointers.

2. The method as described in claim 1 , prior to the traversing of the first objects in the virtual machine heap, the method further comprises:

requesting the N marking threads;

traversing the memory blocks in the virtual machine heap; and

establishing the correspondences between the memory blocks in the virtual machine heap and the N marking threads.

3. The method as described in claim 2 , wherein the establishing of the correspondences between the memory blocks in the virtual machine heap and the N marking threads comprises:

performing one of the following:

designating a corresponding marking thread for at least one memory block; or

designating at least one memory block which at least one marking thread is responsible for marking.

4. The method as described in claim 3 , wherein the establishing of the correspondences between the memory blocks in the virtual machine heap and the N marking threads comprises:

allocating an identifier to a first memory block; and

determining a marking thread identifier corresponding to a first memory block number based on first memory block numbers and a total quantity of the N marking threads.

5. The method as described in claim 4 , wherein the determining of the marking thread identifier corresponding to the first memory block number comprises:

acquiring a remainder from dividing the total quantity of the N marking threads by the first memory block identifier to determine a marking thread identifier corresponding to the at least one memory block.

6. The method as described in claim 1 , wherein the performing of the first mark processing of the first object based on the push-in condition of the first pointer comprises:

in response to a determination that the first pointer was successfully pushed into the private stack of the marking thread corresponding to the memory block where the current first object is located, marking a status corresponding to the first object in a bitmap of the memory block where the current first object is located as pushed-in.

7. A system, comprising:

a processor; and

a memory coupled with the processor, wherein the memory is configured to provide the processor with instructions which when executed cause the processor to:

traverse first objects in a virtual machine heap based on correspondences between memory blocks in the virtual machine heap and N marking threads, wherein N is an integer greater than 1, wherein memory capacity occupied by the N marking threads is preset, wherein each marking thread includes a corresponding private stack, and wherein the memory capacity includes a thread memory capacity of N private stacks;

push a first pointer of a first object of the first objects into a private stack of a marking thread corresponding to a memory block, the first object being located in the memory block, comprising to:

determine whether the private stack of the marking thread is full;

in response to a determination that the private stack of the marking thread is full:

mark the private stack as overflowing; and

mark the first object as having an overflowed status for a push-in condition; and

perform one or more of the following:

record, in a list form, the push-in condition of the first object corresponding to the private stack of the marking thread; and/or

mark a status corresponding to the first object in a bitmap of the memory block where a current first object is located;

perform first mark processing of the first object based on the push-in condition of the first pointer, comprising to:

determine whether the private stack is overflowing; and

in response to a determination that the private stack is overflowing, omit performing the first mark processing of the first object until the private stack has new processing space; and

after traversal of the first objects has been completed, launching the N marking threads to cause the N marking threads to synchronously perform mark processing used in garbage collection based on push-in conditions of first pointers in respective private stacks of the first pointers.